support appProxy for runner init (#555)

* support appProxy for runner init

Author: oren-codefresh

lib/binary/runner.js

@@ -25,6 +25,15 @@ class Runner {
             });
         });
     }
+
+    runAndAttach(component, args) {
+        const dir = join(this.location, component.local.dir);
+        const path = join(dir, component.local.binary);
+        const cp = spawn(path, args, {
+            stdio: [process.stdin, process.stdout, process.stderr, 'pipe'],
+        });
+        return cp;
+    }
 }
 
 module.exports = { Runner };

lib/interface/cli/commands/hybrid/helper.js

@@ -615,6 +615,56 @@ async function installRuntime({
     await componentRunner.run(components.venona, cmd);
 }
 
+async function installAppProxy({
+    kubeContextName, // kube-context-name
+    kubeNamespace, // --kube-namespace
+    kubeConfigPath, // --kube-config-path
+    verbose, // --verbose
+    logFormatting = DefaultLogFormatter, // --log-formtter
+}) {
+    const binLocation = await downloadVeonona();
+    const componentRunner = new Runner(binLocation);
+    const cmd = [
+        'install',
+        'app-proxy',
+        '--kube-context-name',
+        kubeContextName,
+        '--kube-namespace',
+        kubeNamespace,
+        '--log-formtter',
+        logFormatting,
+    ];
+
+    if (kubeConfigPath) {
+        cmd.push(`--kube-config-path=${kubeConfigPath}`);
+    }
+    if (verbose) {
+        cmd.push('--verbose');
+    }
+    if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
+        cmd.push('--insecure');
+    }
+    const cp = componentRunner.runAndAttach(components.venona, cmd, true);
+    const chunks = [];
+    let ingressIp;
+    cp.stdio[3].on('data', (chunk) => {
+        chunks.push(chunk);
+    });
+    cp.stdio[3].on('end', () => {
+        const data = JSON.parse(Buffer.concat(chunks).toString());
+        ingressIp = _.get(data, 'ingressIP');
+    });
+    return new Promise((resolveFn, rejectFn) => {
+        cp.on('exit', (code) => {
+            if (code !== 0) {
+                rejectFn(new Error(`Component exited with status code ${code}`));
+            } else {
+                resolveFn(ingressIp);
+            }
+        });
+    });
+}
+
 async function attachRuntime({
     kubeServiceAccount, // kube-service-account
     kubeContextName, // kube-context-name
@@ -800,6 +850,7 @@ module.exports = {
     detectProxy,
     serealizeToKeyValuePairs,
     getRuntimeImagesWithRegistryUrl,
+    installAppProxy,
     INSTALLATION_DEFAULTS,
     DefaultLogFormatter,
 };

lib/interface/cli/commands/hybrid/init.cmd.js

@@ -27,6 +27,7 @@ const {
     runClusterAcceptanceTests,
     installAgent,
     installRuntime,
+    installAppProxy,
     attachRuntime,
     newRuntimeName,
     newAgentName,
@@ -158,6 +159,11 @@ const initCmd = new Command({
         .option('env-vars', {
             describe: 'Addiontal env vars to be used in agent\'s pod',
             type: array,
+        })
+        .option('app-proxy', {
+            describe: 'install app proxy component (default false)',
+            default: false,
+            type: 'boolean',
         }),
     handler: async (argv) => {
         let resumedInstallation = false;
@@ -181,56 +187,59 @@ const initCmd = new Command({
             _argv = Object.assign(oldInstallationPlan.getContext('argv'), _argv); // restore previous installation environment
         }
 
-        let {
+        const {
             'kube-node-selector': kubeNodeSelector,
             'build-node-selector': buildNodeSelector,
             tolerations,
             'kube-config-path': kubeConfigPath,
             'storage-class-name': storageClassName,
-            'yes': noQuestions,
             verbose,
-            name, url,
-            token,
-            'values': valuesFile,
+            values: valuesFile,
             'set-value': setValue,
             'set-file': setFile,
             'skip-cluster-test': skipClusterTest,
-            'install-monitor': installMonitor,
             'docker-registry': dockerRegistry,
-        
+            'app-proxy': appProxy,
+        } = _argv;
+        let {
+            yes: noQuestions,
             'kube-context-name': kubeContextName,
             'kube-namespace': kubeNamespace,
             'set-default-runtime': shouldMakeDefaultRe,
             'exec-demo-pipeline': shouldExecutePipeline,
             'env-vars': envVars,
             'http-proxy': httpProxy,
             'https-proxy': httpsProxy,
+            url,
+            token,
+            name,
+            'install-monitor': installMonitor,
         } = _argv;
 
         let valuesObj;
         if (valuesFile) {
-            let valuesFileStr = fs.readFileSync(valuesFile, 'utf8');
+            const valuesFileStr = fs.readFileSync(valuesFile, 'utf8');
             valuesObj = YAML.parse(valuesFileStr);
             noQuestions = true;
 
-            if ( !kubeNamespace && valuesObj.Namespace ) {
+            if (!kubeNamespace && valuesObj.Namespace) {
                 kubeNamespace = valuesObj.Namespace;
             }
-            if ( !kubeContextName && valuesObj.Context ) {
+            if (!kubeContextName && valuesObj.Context) {
                 kubeContextName = valuesObj.Context;
             }
-            if ( !url && valuesObj.CodefreshHost ) {
+            if (!url && valuesObj.CodefreshHost) {
                 url = valuesObj.CodefreshHost;
             }
-            if ( !token && valuesObj.Token ) {
+            if (!token && valuesObj.Token) {
                 token = valuesObj.Token;
             }
-            if ( !name && valuesObj.AgentId ) {
+            if (!name && valuesObj.AgentId) {
                 name = valuesObj.AgentId;
             }
-            if ( typeof _.get(valuesObj, "Monitor.Enabled" ) !== 'undefined' ) {
-                installMonitor = _.get(valuesObj, "Monitor.Enabled");
-            }                                             
+            if (typeof _.get(valuesObj, 'Monitor.Enabled') !== 'undefined') {
+                installMonitor = _.get(valuesObj, 'Monitor.Enabled');
+            }
         }
         if (!url) {
             url = DEFAULTS.URL;
@@ -396,7 +405,7 @@ const initCmd = new Command({
         installationPlan.addContext('argv', _argv);
 
         // run cluster acceptance tests
-        if (! _.get(valuesObj, "SkipClusterTest")) {        
+        if (!_.get(valuesObj, 'SkipClusterTest')) {
             installationPlan.addStep({
                 name: 'run cluster acceptance tests',
                 func: runClusterAcceptanceTests,
@@ -450,7 +459,7 @@ const initCmd = new Command({
                     envVars,
                     valuesFile, // --values
                     setValue, // --set-value
-                    setFile, // --set-file                    
+                    setFile, // --set-file
                 });
             },
             installationEvent: installationProgress.events.AGENT_INSTALLED,
@@ -584,6 +593,38 @@ const initCmd = new Command({
             installationEvent: installationProgress.events.RUNTIME_INSTALLED,
         });
 
+        installationPlan.addStep({
+            name: 'install app-proxy',
+            func: async () => {
+                const appProxyIP = await installAppProxy({
+                    kubeContextName,
+                    kubeNamespace,
+                    verbose,
+                    kubeConfigPath,
+                });
+                installationPlan.addContext('appProxyIP', appProxyIP);
+            },
+            installationEvent: installationProgress.events.APP_PROXY_INSTALLED,
+            condition: !!appProxy,
+        });
+
+        // update runtime with ingress IP
+        installationPlan.addStep({
+            name: 'update runtime environment app proxy ip',
+            func: async () => {
+                const reName = installationPlan.getContext('runtimeName');
+                const re = await sdk.runtimeEnvs.get({ name: reName });
+                const body = {
+                    appProxy: {
+                        externalIP: installationPlan.getContext('appProxyIP'),
+                    },
+                };
+                await sdk.runtimeEnvs.update({ name: reName }, _.merge(re, body));
+                console.log(`Runtime environment "${colors.cyan(reName)}" has been updated with the app proxy`);
+            },
+            condition: async () => installationPlan.getContext('appProxyIP'),
+        });
+
         // update agent with new runtime
         installationPlan.addStep({
             name: 'update agent with new runtime',

lib/interface/cli/commands/hybrid/installation-process.js

@@ -39,6 +39,7 @@ module.exports = {
         CLUSTER_INTEGRATION_ADDED: 'cluster-integration-added',
         AGENT_UPDATED: 'agent-updated',
         RUNTIME_INSTALLED: 'runtime-installed',
+        APP_PROXY_INSTALLED: 'app-proxy-installed',
         PIPELINE_EXECUTED: 'demo-pipeline-executed',
         PIPELINE_CREATED: 'demo-pipeline-created',
         FINISHED: 'finished',