Use of the kubeless http trigger instead of a custom created ingress (#…

…206)

lib/deploy.js

@@ -21,8 +21,8 @@ const BbPromise = require('bluebird');
 const Api = require('kubernetes-client');
 const CRD = require('./crd');
 const helpers = require('./helpers');
-const ingressHelper = require('./ingress');
 const moment = require('moment');
+const url = require('url');
 
 /** Supported message queue types */
 const MQTypes = Object.freeze({ kafka: 'Kafka', nats: 'NATS' });
@@ -434,6 +434,49 @@ function deployScheduleTrigger(name, namespace, schedule, options) {
     });
 }
 
+function deployHttpTrigger(name, namespace, path, options) {
+  if (options.ingress.enableTlsAcme && options.ingress.tlsSecretName) {
+    throw new Error('Cannot specify both enableTlsAcme and tlsSecretName');
+  }
+  // fix for issue https://github.com/kubeless/kubeless/issues/1124
+  const baseAnnotations = {
+    'kubernetes.io/ingress.class': options.ingress.class || 'nginx',
+  };
+  // end fix
+  const trigger = {
+    apiVersion: 'kubeless.io/v1beta1',
+    kind: 'HTTPTrigger',
+    metadata: {
+      name,
+      namespace,
+      labels: {
+        'created-by': 'kubeless',
+      },
+      annotations: Object.assign(baseAnnotations, options.ingress.additionalAnnotations),
+    },
+    spec: {
+      'basic-auth-secret': options.ingress.basicAuthSecretName || '',
+      'cors-enable': options.ingress.cors || false,
+      'function-name': name,
+      gateway: options.ingress.class || 'nginx',  // not working: https://github.com/kubeless/kubeless/issues/1124
+      'host-name': options.hostname,
+      path: path.replace(/^\//, ''),
+      tls: options.ingress.enableTlsAcme || false,
+      'tls-secret': options.ingress.tlsSecretName || '',
+    },
+  };
+  const httpTriggerApi = new CRD('apis/kubeless.io', 'v1beta1', namespace, 'httptriggers');
+  options.log(`Creating http trigger for: ${trigger.metadata.name}`);
+  return httpTriggerApi.getItem(trigger.metadata.name)
+    .then((res) => {
+      if (res.code === 404) {
+        return httpTriggerApi.post({ body: trigger });
+      }
+      options.log('Updating existing http trigger');
+      return httpTriggerApi.put(trigger.metadata.name, { body: trigger });
+    });
+}
+
 function deployFunction(f, namespace, runtime, contentType, options) {
   const functionsApi = new CRD('apis/kubeless.io', 'v1beta1', namespace, 'functions');
   let environment = options.environment ? parseEnv(options.environment) : null;
@@ -527,10 +570,27 @@ function handleMQTDeployment(trigger, name, namespace, options) {
 }
 
 function deployTrigger(event, funcName, namespace, service, options) {
-  let triggerPromise = new BbPromise((r) => r());
+  let triggerPromise;
+  let config;
+  let defaultHostname;
   switch (event.type) {
     case 'http':
-      // TODO: Rely on Kubeless httptrigger object when it support paths
+      if (_.isEmpty(event.path)) {
+        throw new Error('You should specify a path for the trigger event');
+      }
+      config = helpers.loadKubeConfig();
+      // eslint-disable-next-line max-len
+      defaultHostname = `${url.parse(helpers.getKubernetesAPIURL(config)).hostname}.${options.defaultDNSResolution || 'nip.io'}`;
+      triggerPromise = deployHttpTrigger(
+        funcName,
+        namespace,
+        event.path,
+        {
+          log: options.log,
+          ingress: options.ingress || {},
+          hostname: event.hostname || options.hostname || defaultHostname,
+        }
+      );
       break;
     case 'trigger':
       if (_.isEmpty(event.trigger)) {
@@ -586,38 +646,20 @@ function deploy(functions, runtime, service, options) {
             if (res.code && res.code !== 200) {
               errors.push(res.message);
             }
-            counter++;
-            helpers.checkFinished(counter, elements, errors, resolve, reject, {
-              onSuccess: () => ingressHelper.addIngressRuleIfNecessary(service, functions, {
-                verbose: options.verbose,
-                log: options.log,
-                hostname: options.hostname,
-                defaultDNSResolution: options.defaultDNSResolution,
-                ingress: options.ingress,
-                namespace: ns,
-              }),
+            _.each(description.events, event => {
+              deployTrigger(event, description.id, ns, service, opts)
+                .catch(triggerErr => errors.push(triggerErr))
+                .then((tr) => {
+                  if (tr && tr.code && tr.code !== 200) {
+                    errors.push(tr.message);
+                  }
+                  counter++;
+                  helpers.checkFinished(counter, elements, errors, resolve, reject);
+                });
             });
+            counter++;
+            helpers.checkFinished(counter, elements, errors, resolve, reject);
           });
-        _.each(description.events, event => {
-          deployTrigger(event, description.id, ns, service, opts)
-            .catch(triggerErr => errors.push(triggerErr))
-            .then((res) => {
-              if (res && res.code && res.code !== 200) {
-                errors.push(res.message);
-              }
-              counter++;
-              helpers.checkFinished(counter, elements, errors, resolve, reject, {
-                onSuccess: () => ingressHelper.addIngressRuleIfNecessary(service, functions, {
-                  verbose: options.verbose,
-                  log: options.log,
-                  hostname: options.hostname,
-                  defaultDNSResolution: options.defaultDNSResolution,
-                  ingress: options.ingress,
-                  namespace: ns,
-                }),
-              });
-            });
-        });
       } else {
         counter++;
         opts.log(

lib/get-info.js

@@ -93,13 +93,24 @@ function info(functions, service, options) {
       });
       const core = new Api.Core(connectionOptions);
       const functionsApi = new CRD('apis/kubeless.io', 'v1beta1', namespace, 'functions');
-      const extensions = new Api.Extensions(connectionOptions);
+      const httpTriggerApi = new CRD('apis/kubeless.io', 'v1beta1', namespace, 'httptriggers');
       core.ns.services.get((err, servicesInfo) => {
         if (err) reject(new Error(err));
         functionsApi.getItem(f).catch((ferr) => reject(ferr)).then(fDesc => {
-          extensions.ns.ingress(service).get((ierr, fIngress) => {
-            if (ierr && !ierr.message.match(/not found/)) {
-              reject(new Error(ierr));
+          let tErr;
+          let httpTriggerDesc;
+          httpTriggerApi.getItem(f).catch((ex) => {
+            tErr = ex;
+          }).then(res => {
+            if (res && res.kind === 'Status') {
+              tErr = res;
+            } else {
+              httpTriggerDesc = res;
+            }
+          }).finally(() => {
+            // eslint-disable-next-line max-len
+            if (tErr && (tErr.code && tErr.code !== 404)) {
+              reject(new Error(tErr));
             }
             const functionService = _.find(
               servicesInfo.items,
@@ -112,12 +123,9 @@ function info(functions, service, options) {
               opts.log(`Not found any information about the function "${f}"`);
             } else {
               let url = null;
-              if (fIngress) {
-                const rule = _.find(fIngress.spec.rules,
-                  r => _.some(r.http.paths, p => p.backend.serviceName === f)
-                );
-                const path = _.find(rule.http.paths, p => p.backend.serviceName === f).path;
-                url = `${rule.host || 'API_URL'}${path}`;
+              if (httpTriggerDesc) {
+                // eslint-disable-next-line max-len
+                url = `${httpTriggerDesc.spec['host-name'] || 'API_URL'}/${httpTriggerDesc.spec.path}`;
               }
               const fService = {
                 name: functionService.metadata.name,