codefresh 1.2.11 → 1.2.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/lib/binary/components.js +38 -0
  2. package/lib/interface/cli/commands/agent/helper.js +28 -0
  3. package/lib/interface/cli/commands/agent/install.cmd.js +283 -0
  4. package/lib/interface/cli/commands/agent/uninstall.cmd.js +92 -0
  5. package/lib/interface/cli/commands/app-proxy/helper.js +63 -0
  6. package/lib/interface/cli/commands/app-proxy/install.cmd.js +204 -0
  7. package/lib/interface/cli/commands/app-proxy/uninstall.cmd.js +175 -0
  8. package/lib/interface/cli/commands/app-proxy/upgrade.cmd.js +110 -0
  9. package/lib/interface/cli/commands/components/download.cmd.js +1 -1
  10. package/lib/interface/cli/commands/gitops/argocd/install.js +9 -0
  11. package/lib/interface/cli/commands/gitops/argocd/uninstall.js +11 -0
  12. package/lib/interface/cli/commands/gitops/argocd/upgrade.js +9 -0
  13. package/lib/interface/cli/commands/gitops/codefresh/install.js +50 -0
  14. package/lib/interface/cli/commands/gitops/codefresh/uninstall.js +14 -0
  15. package/lib/interface/cli/commands/gitops/codefresh/upgrade.js +9 -0
  16. package/lib/interface/cli/commands/gitops/common/install.js +62 -0
  17. package/lib/interface/cli/commands/gitops/common/uninstall.js +39 -0
  18. package/lib/interface/cli/commands/gitops/common/upgrade.js +45 -0
  19. package/lib/interface/cli/commands/gitops/install.cmd.js +116 -0
  20. package/lib/interface/cli/commands/gitops/install.spec.js +77 -0
  21. package/lib/interface/cli/commands/gitops/uninstall.cmd.js +56 -0
  22. package/lib/interface/cli/commands/gitops/upgrade.cmd.js +56 -0
  23. package/lib/interface/cli/commands/hybrid/delete.cmd.js +341 -0
  24. package/lib/interface/cli/commands/hybrid/helper.js +877 -1
  25. package/lib/interface/cli/commands/hybrid/init.cmd.js +957 -0
  26. package/lib/interface/cli/commands/hybrid/key-helper.js +82 -0
  27. package/lib/interface/cli/commands/hybrid/migration.js +192 -0
  28. package/lib/interface/cli/commands/hybrid/upgrade.cmd.js +195 -0
  29. package/lib/interface/cli/commands/monitor/install.cmd.js +160 -0
  30. package/lib/interface/cli/commands/monitor/uninstall.cmd.js +78 -0
  31. package/lib/interface/cli/commands/root/install.cmd.js +17 -0
  32. package/lib/interface/cli/commands/root/uninstall.cmd.js +17 -0
  33. package/lib/interface/cli/commands/runtimeEnvironments/attach.cmd.js +180 -0
  34. package/lib/interface/cli/commands/runtimeEnvironments/create.cmd.js +23 -0
  35. package/lib/interface/cli/commands/runtimeEnvironments/install.cmd.js +340 -0
  36. package/lib/interface/cli/commands/runtimeEnvironments/uninstall.cmd.js +149 -0
  37. package/lib/interface/cli/completion/tree.json +1 -1
  38. package/lib/interface/cli/helpers/kubernetes.js +61 -0
  39. package/lib/interface/cli/helpers/progressEvents.js +25 -0
  40. package/package.json +11 -2
@@ -0,0 +1,957 @@
1
+ /* eslint-disable max-len */
2
+ const fs = require('fs');
3
+
4
+ const Command = require('../../Command');
5
+ const runnerRoot = require('../root/runner.cmd');
6
+ const inquirer = require('inquirer').default;
7
+ const colors = require('colors');
8
+ const _ = require('lodash');
9
+ const { addProxyVariables, detectProxy, keyValueArrayToObject } = require('../../helpers/general');
10
+ const { getAllKubeContexts, getKubeContext, isInCluster } = require('../../helpers/kubernetes');
11
+ const installMonitoring = require('../monitor/install.cmd');
12
+ const createClusterCmd = require('../cluster/create.cmd');
13
+ const createContext = require('../auth/create-context.cmd');
14
+ const getAgents = require('../agent/get.cmd');
15
+ const { getConfigForSdk } = require('../../commad-line-interface');
16
+ const DEFAULTS = require('../../defaults');
17
+ const sdk = require('../../../../logic/sdk');
18
+ const installationProgress = require('./installation-process');
19
+ const { to } = require('./../../../../logic/cli-config/errors/awaitTo');
20
+ const {
21
+ createErrorHandler,
22
+ drawCodefreshFiglet,
23
+ getDefaultRuntime,
24
+ getRecommendedKubeNamespace,
25
+ runClusterAcceptanceTests,
26
+ installAgent,
27
+ installRuntime,
28
+ installAppProxy,
29
+ attachRuntime,
30
+ newRuntimeName,
31
+ newAgentName,
32
+ keyValueAsStringToObject,
33
+ getRuntimeImagesWithRegistryUrl,
34
+ mergeValuesFromValuesFile,
35
+ INSTALLATION_DEFAULTS,
36
+ } = require('./helper');
37
+ const InstallationPlan = require('./InstallationPlan');
38
+ const { produceVenonaKeys } = require('./key-helper');
39
+ const { array } = require('yargs');
40
+ const {
41
+ addPipelineToInstallationPlan,
42
+ } = require('./pipeline-helper');
43
+
44
+ const defaultDockerRegistry = 'quay.io';
45
+ const handleError = createErrorHandler(`\nIf you had any issues with the installation please report them at: ${colors.blue('https://github.com/codefresh-io/cli/issues/new')}`);
46
+
47
+ async function isNewAccount() {
48
+ const [pipelines, err] = await to(sdk.pipelines.list({}));
49
+ if (!err && _.isArray(_.get(pipelines, 'docs'))) {
50
+ return !pipelines.docs.length;
51
+ }
52
+
53
+ return false;
54
+ }
55
+
56
+ function printInstallationOptionsSummary({
57
+ kubeContextName,
58
+ kubeNamespace,
59
+ shouldMakeDefaultRe,
60
+ shouldExecutePipeline,
61
+ httpProxy,
62
+ httpsProxy,
63
+ noProxy,
64
+ appProxy,
65
+ appProxyHost,
66
+ appProxyPathPrefix,
67
+ dryRun,
68
+ shouldUseHelm,
69
+ }) {
70
+ let summary = `\n${colors.green('Installation options summary:')}
71
+ 1. Kubernetes Context: ${colors.cyan(kubeContextName)}
72
+ 2. Kubernetes Namespace: ${colors.cyan(kubeNamespace)}
73
+ 3. Set this as default account runtime-environment: ${colors.cyan(!!shouldMakeDefaultRe)}
74
+ 4. Execute demo pipeline after install: ${colors.cyan(!!shouldExecutePipeline)}
75
+ 5. HTTP proxy: ${httpProxy ? colors.cyan(httpProxy) : 'none'}
76
+ 6. HTTPS proxy: ${httpsProxy ? colors.cyan(httpsProxy) : 'none'}
77
+ 7. No proxy: ${noProxy ? colors.cyan(noProxy) : 'none'}
78
+ `;
79
+
80
+ if (appProxy) {
81
+ summary += `7. App-Proxy address: ${colors.cyan(`https://${appProxyHost}${appProxyPathPrefix || ''}`)}\n`;
82
+ }
83
+ if (dryRun) {
84
+ summary += '**** running in dry-run mode ****';
85
+ }
86
+ if (shouldUseHelm) {
87
+ summary += '**** running in helm values generation mode ****';
88
+ }
89
+ console.log(summary);
90
+ }
91
+
92
+ const initCmd = new Command({
93
+ root: false,
94
+ parent: runnerRoot,
95
+ command: 'init',
96
+ requiresAuthentication: false,
97
+ description: 'Install Codefresh Runner solution\'s components on Kubernetes cluster',
98
+ webDocs: {
99
+ category: 'Runner',
100
+ title: 'Init',
101
+ weight: 100,
102
+ },
103
+ // requiresAuthentication: argv => argv && !argv.token,
104
+ builder: yargs => yargs
105
+ .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
106
+ .option('name', {
107
+ describe: 'Agent\'s name to be created if token is not provided',
108
+ })
109
+ .option('token', {
110
+ describe: 'Registration\'s token',
111
+ })
112
+ .option('url', {
113
+ describe: 'Codefresh system custom url',
114
+ })
115
+ .option('generate-helm-values-file', {
116
+ describe: 'Path to the new generated helm values file',
117
+ type: 'string',
118
+ })
119
+ .option('kube-context-name', {
120
+ describe: 'Name of the Kubernetes context on which runner should be installed [$CF_ARG_KUBE_CONTEXT_NAME]',
121
+ })
122
+ .option('kube-node-selector', {
123
+ describe: 'The Kubernetes node selector "key=value" to be used by runner build resources (default is no node selector) (string)',
124
+ })
125
+ .option('build-node-selector', {
126
+ describe: 'The Kubernetes node selector "key=value" to be used by the Codefresh build resources (default is no node selector)',
127
+ })
128
+ .option('yes', {
129
+ describe: 'Use installation defaults (don\'t ask any questions)',
130
+ alias: 'y',
131
+ type: 'boolean',
132
+ })
133
+ .option('skip-cluster-test', {
134
+ describe: 'Do not test given kubeconfig context to have all the required permission',
135
+ type: 'boolean',
136
+ })
137
+ .option('skip-cluster-integration', {
138
+ describe: 'Do not create a cluster integration in Codefresh',
139
+ type: 'boolean',
140
+ })
141
+ .option('set-default-runtime', {
142
+ describe: 'Set this as the default runtime environment for your Codefresh account',
143
+ type: 'boolean',
144
+ })
145
+ .option('exec-demo-pipeline', {
146
+ describe: 'Run a demo pipeline after the installation completes',
147
+ type: 'boolean',
148
+ })
149
+ .option('install-monitor', {
150
+ describe: 'Install a monitoring component that will help provide valueable data about your cluster to Codefresh',
151
+ type: 'boolean',
152
+ default: true,
153
+ })
154
+ .option('kube-namespace', {
155
+ describe: 'Name of the namespace on which runner should be installed [$CF_ARG_KUBE_NAMESPACE]',
156
+ })
157
+ .option('tolerations', {
158
+ describe: 'The Kubernetes tolerations as path to a JSON file prefixed with @ to be used by runner resources (default is no tolerations) (string)',
159
+ })
160
+ .option('storage-class-name', {
161
+ describe: 'Set a name of your custom storage class',
162
+ })
163
+ .option('docker-registry', {
164
+ describe: `The prefix for the container registry that will be used for pulling the required components images. Example: --docker-registry="docker.io" default is ${defaultDockerRegistry}`,
165
+ type: 'string',
166
+ default: defaultDockerRegistry,
167
+ })
168
+ .option('kube-config-path', {
169
+ describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
170
+ })
171
+ .option('values', {
172
+ describe: 'specify values in a YAML file (see example here: https://github.com/codefresh-io/venona/blob/release-1.0/venonactl/example/values-example.yaml)',
173
+ })
174
+ .option('set-value', {
175
+ describe: 'Set values for templates, example: --set-value LocalVolumesDir=/mnt/disks/ssd0/codefresh-volumes',
176
+ type: array,
177
+ default: [],
178
+ })
179
+ .option('set-file', {
180
+ describe: 'Set values for templates from file, example: --set-file Storage.GoogleServiceAccount=/path/to/service-account.json',
181
+ type: array,
182
+ default: [],
183
+ })
184
+ .option('http-proxy', {
185
+ describe: 'http proxy to be used in the runner',
186
+ })
187
+ .option('https-proxy', {
188
+ describe: 'https proxy to be used in the runner',
189
+ })
190
+ .option('no-proxy', {
191
+ describe: 'no_proxy to be used in the runner',
192
+ })
193
+ .option('verbose', {
194
+ describe: 'Print logs',
195
+ })
196
+ .option('env-vars', {
197
+ describe: 'Addiontal env vars to be used in all Codefresh components',
198
+ type: array,
199
+ default: [],
200
+ })
201
+ .option('app-proxy', {
202
+ describe: 'install app proxy component (default false)',
203
+ default: false,
204
+ type: 'boolean',
205
+ })
206
+ .option('app-proxy-host', {
207
+ describe: 'the hostname that will be used by the app-proxy ingress',
208
+ type: 'string',
209
+ })
210
+ .option('app-proxy-ingress-class', {
211
+ describe: 'the ingress class that will be used by the app-proxy ingress',
212
+ type: 'string',
213
+ })
214
+ .option('docker-daemon-access', {
215
+ describe: 'docker daemon access (default true)',
216
+ default: true,
217
+ type: 'boolean',
218
+ })
219
+ .option('dry-run', {
220
+ describe: 'Will save all of the manifests to be deployed on the cluster to: ./manifests/',
221
+ default: false,
222
+ type: 'boolean',
223
+ })
224
+ .option('bypass-download', {
225
+ describe: 'Will bypass the attempt to download the installer. Instead, will immediately attempt to use the binary from the components folder',
226
+ default: false,
227
+ type: 'boolean',
228
+ })
229
+ .example(
230
+ 'codefresh runner init --values values.yaml',
231
+ 'See values file example here: https://github.com/codefresh-io/venona/blob/release-1.0/venonactl/example/values-example.yaml)',
232
+ ),
233
+ handler: async (argv) => {
234
+ let resumedInstallation = false;
235
+
236
+ const oldInstallationPlan = InstallationPlan.restorePreviousState();
237
+ if (oldInstallationPlan) {
238
+ console.log(colors.cyan('Previous installation state:'));
239
+ oldInstallationPlan.printState();
240
+ oldInstallationPlan.reset(); // needs to be called after printState()
241
+ const answer = await inquirer.prompt({
242
+ type: 'confirm',
243
+ name: 'resumeInstallation',
244
+ default: INSTALLATION_DEFAULTS.RESUME_OLD_INSTALLATION,
245
+ message: 'Detected previous incomplete installation, do you want to resume this installation?',
246
+ });
247
+ resumedInstallation = answer.resumeInstallation;
248
+ }
249
+
250
+ let _argv = argv;
251
+ if (resumedInstallation) {
252
+ _argv = Object.assign(oldInstallationPlan.getContext('argv'), _argv); // restore previous installation environment
253
+ }
254
+
255
+ // if we are using a values file
256
+ if (_argv.values) {
257
+ _argv = mergeValuesFromValuesFile(_argv, _argv.values, handleError);
258
+ }
259
+
260
+ const {
261
+ 'kube-node-selector': kubeNodeSelector,
262
+ 'build-node-selector': buildNodeSelector,
263
+ tolerations,
264
+ 'kube-config-path': kubeConfigPath,
265
+ 'storage-class-name': storageClassName,
266
+ verbose,
267
+ values: valuesFile,
268
+ 'set-value': setValue,
269
+ 'set-file': setFile,
270
+ 'app-proxy-ingress-class': appProxyIngressClass,
271
+ 'env-vars': envVars,
272
+ yes: noQuestions,
273
+ 'skip-cluster-test': skipClusterTest,
274
+ 'skip-cluster-integration': skipClusterIntegration,
275
+ 'docker-registry': dockerRegistry,
276
+ token,
277
+ name,
278
+ 'app-proxy': appProxy,
279
+ 'app-proxy-path-prefix': appProxyPathPrefix,
280
+ 'install-monitor': installMonitor,
281
+ 'docker-daemon-access': dockerDaemonAccess,
282
+ runtimeName,
283
+ reEnvVars,
284
+ reResources,
285
+ reTolerations,
286
+ userVolumeMounts,
287
+ userVolumes,
288
+ 'dry-run': dryRun,
289
+ 'bypass-download': bypassDownload,
290
+ } = _argv;
291
+
292
+ let {
293
+ 'generate-helm-values-file': helmValuesFile,
294
+ 'kube-context-name': kubeContextName,
295
+ 'kube-namespace': kubeNamespace,
296
+ 'set-default-runtime': shouldMakeDefaultRe,
297
+ 'exec-demo-pipeline': shouldExecutePipeline,
298
+ 'http-proxy': httpProxy,
299
+ 'https-proxy': httpsProxy,
300
+ 'no-proxy': noProxy,
301
+ 'app-proxy-host': appProxyHost,
302
+ url,
303
+ } = _argv;
304
+
305
+ if (!url) {
306
+ url = DEFAULTS.URL;
307
+ }
308
+
309
+ if (helmValuesFile === '') {
310
+ // if the user specified the --generate-helm-values-file flag
311
+ // but did not specify file path, use a default path
312
+ helmValuesFile = INSTALLATION_DEFAULTS.HELM_FILE_PATH;
313
+ }
314
+ const shouldUseHelm = !!helmValuesFile;
315
+
316
+ if (_.get(sdk, 'config.context.isNoAuth') && !token) {
317
+ console.log('Not authenticated as a Codefresh account: ');
318
+ console.log('In order to install a Codefresh Runner you need to provide ' +
319
+ `an authentication token which can be generated here: ${colors.blue(`${_argv.url}/user/settings`)}` +
320
+ '\nAfter getting the token you may run this command again with the [--token] option or use the \'codefresh auth\' command to create an authenticated context.');
321
+ process.exit(1);
322
+ }
323
+
324
+ const detectedProxyVars = detectProxy();
325
+ httpProxy = httpProxy || detectedProxyVars.httpProxy;
326
+ httpsProxy = httpsProxy || detectedProxyVars.httpsProxy;
327
+ noProxy = noProxy || detectedProxyVars.noProxy;
328
+
329
+ if (noQuestions) {
330
+ // use defaults
331
+ kubeContextName = kubeContextName || getKubeContext(kubeConfigPath);
332
+ kubeNamespace = kubeNamespace || await getRecommendedKubeNamespace(kubeConfigPath, kubeContextName);
333
+ shouldMakeDefaultRe = _.isUndefined(shouldMakeDefaultRe) ? INSTALLATION_DEFAULTS.MAKE_DEFAULT_RE : shouldMakeDefaultRe;
334
+ shouldExecutePipeline = _.isUndefined(shouldExecutePipeline) ? INSTALLATION_DEFAULTS.RUN_DEMO_PIPELINE : shouldExecutePipeline;
335
+ } else if (!resumedInstallation) {
336
+ console.log(colors.green('This installer will guide you through the Codefresh Runner installation process'));
337
+ if (!kubeContextName) {
338
+ const contexts = getAllKubeContexts(kubeConfigPath);
339
+ const currentKubeContext = getKubeContext(kubeConfigPath);
340
+
341
+ const answer = await inquirer.prompt({
342
+ type: 'list',
343
+ name: 'context',
344
+ message: 'Name of Kubernetes context to use',
345
+ default: currentKubeContext,
346
+ choices: contexts,
347
+ });
348
+ kubeContextName = answer.context; // need this to set the default kube namespace in the next question
349
+ }
350
+
351
+ const questions = [];
352
+ if (!kubeNamespace) {
353
+ questions.push({
354
+ type: 'input',
355
+ name: 'namespace',
356
+ default: await getRecommendedKubeNamespace(kubeConfigPath, kubeContextName),
357
+ message: 'Kubernetes namespace to install into (will be created if it does not exist)',
358
+ validate: value => (value !== undefined && value !== '') || 'Please enter namespace\'s name',
359
+ });
360
+ }
361
+ if (httpProxy) {
362
+ questions.push({
363
+ type: 'input',
364
+ name: 'httpProxy',
365
+ default: httpProxy,
366
+ message: 'detected HTTP_PROXY, should I use this in all Codefresh components?',
367
+ });
368
+ }
369
+
370
+ if (httpsProxy) {
371
+ questions.push({
372
+ type: 'input',
373
+ name: 'httpsProxy',
374
+ default: httpsProxy,
375
+ message: 'detected HTTPS_PROXY, should I use this in all Codefresh components?',
376
+
377
+ });
378
+ }
379
+ if (noProxy) {
380
+ questions.push({
381
+ type: 'input',
382
+ name: 'noProxy',
383
+ default: noProxy,
384
+ message: 'detected NO_PROXY, should I use this in all Codefresh components?',
385
+
386
+ });
387
+ }
388
+
389
+ if (appProxy && !appProxyHost) {
390
+ // will only be asked if you want to install app-proxy but you give no host in the options
391
+ questions.push({
392
+ type: 'input',
393
+ name: 'appProxyHost',
394
+ message: 'The hostname that will be used by the app-proxy ingress',
395
+ });
396
+ }
397
+
398
+ if (_.isUndefined(shouldMakeDefaultRe)) {
399
+ if (!_.get(sdk, 'config.context.isNoAuth') && await isNewAccount()) {
400
+ // don't ask and set this runtime as default if it's a new account
401
+ shouldMakeDefaultRe = true;
402
+ } else {
403
+ let message = 'Set this as the default runtime environment for your Codefresh account?';
404
+ const [, defaultRe] = await to(getDefaultRuntime());
405
+ if (defaultRe) {
406
+ message = `Change the current default runtime "${colors.cyan(defaultRe.metadata.name)}" to new runtime ?`;
407
+ }
408
+ questions.push({
409
+ type: 'confirm',
410
+ name: 'shouldMakeDefaultRe',
411
+ default: INSTALLATION_DEFAULTS.MAKE_DEFAULT_RE,
412
+ message,
413
+ });
414
+ }
415
+ }
416
+
417
+ if (_.isUndefined(shouldExecutePipeline)) {
418
+ questions.push({
419
+ type: 'confirm',
420
+ name: 'shouldExecutePipeline',
421
+ default: INSTALLATION_DEFAULTS.RUN_DEMO_PIPELINE,
422
+ message: shouldUseHelm ? 'Create demo pipeline?' : 'Run demo pipeline after install?',
423
+ });
424
+ }
425
+
426
+ const answers = await inquirer.prompt(questions);
427
+ kubeContextName = kubeContextName || answers.context;
428
+ kubeNamespace = kubeNamespace || answers.namespace;
429
+ appProxyHost = appProxyHost || answers.appProxyHost;
430
+ shouldMakeDefaultRe = _.isUndefined(shouldMakeDefaultRe) ? answers.shouldMakeDefaultRe : shouldMakeDefaultRe;
431
+ shouldExecutePipeline = _.isUndefined(shouldExecutePipeline) ? answers.shouldExecutePipeline : shouldExecutePipeline;
432
+ // eslint-disable-next-line object-curly-newline
433
+ ({ httpProxy, httpsProxy, noProxy } = answers);
434
+ }
435
+
436
+ printInstallationOptionsSummary({
437
+ kubeContextName,
438
+ kubeNamespace,
439
+ shouldMakeDefaultRe,
440
+ shouldExecutePipeline,
441
+ httpProxy,
442
+ httpsProxy,
443
+ noProxy,
444
+ appProxy,
445
+ appProxyHost,
446
+ appProxyPathPrefix,
447
+ dryRun,
448
+ shouldUseHelm,
449
+ });
450
+
451
+ if (token) {
452
+ // Create a new context and switch to that context
453
+ const [err] = await to(createContext.handler({
454
+ apiKey: token,
455
+ name: INSTALLATION_DEFAULTS.CF_CONTEXT_NAME,
456
+ url,
457
+ }));
458
+ await handleError(err, 'Failed to use the provided token');
459
+ const config = await getConfigForSdk();
460
+ await sdk.configure(config);
461
+ console.log(`A Codefresh context named '${INSTALLATION_DEFAULTS.CF_CONTEXT_NAME}' was added to your "cfconfig" file.`);
462
+ }
463
+
464
+ const progress = dryRun ? {} : await installationProgress.create(sdk['runner-installation'], {
465
+ options: {
466
+ kubeContextName,
467
+ kubeNamespace,
468
+ shouldMakeDefaultRe,
469
+ shouldExecutePipeline,
470
+ },
471
+ });
472
+ const progressReporter = installationProgress.buildReporter(sdk['runner-installation'], progress);
473
+
474
+ let installationPlan;
475
+ if (resumedInstallation) {
476
+ installationPlan = oldInstallationPlan;
477
+ installationPlan.setErrorHandler(handleError);
478
+ installationPlan.setProgressReporter(progressReporter);
479
+ } else {
480
+ installationPlan = new InstallationPlan({ progressReporter, errHandler: handleError });
481
+ }
482
+
483
+ addProxyVariables(envVars, { httpsProxy, httpProxy, noProxy });
484
+
485
+ // save the answers for backup
486
+ _argv['kube-context-name'] = kubeContextName;
487
+ _argv['kube-namespace'] = kubeNamespace;
488
+ _argv['set-default-runtime'] = shouldMakeDefaultRe;
489
+ _argv['exec-demo-pipeline'] = shouldExecutePipeline;
490
+ _argv['env-vars'] = envVars;
491
+ _argv['app-proxy-host'] = appProxyHost;
492
+ installationPlan.addContext('argv', _argv);
493
+
494
+ // run cluster acceptance tests
495
+ installationPlan.addStep({
496
+ name: 'run cluster acceptance tests',
497
+ func: runClusterAcceptanceTests,
498
+ arg: {
499
+ apiHost: sdk.config.context.url,
500
+ kubeNamespace,
501
+ kubeConfigPath,
502
+ kubeContextName,
503
+ dockerRegistry,
504
+ envVars,
505
+ verbose,
506
+ valuesFile,
507
+ setValue,
508
+ setFile,
509
+ bypassDownload,
510
+ },
511
+ installationEvent: installationProgress.events.ACCEPTANCE_TESTS_RAN,
512
+ condition: !skipClusterTest && !shouldUseHelm,
513
+ });
514
+
515
+ // generate new agent name
516
+ installationPlan.addContext('agentName', name ? name.trim() : name);
517
+ installationPlan.addStep({
518
+ name: 'generate new agent name',
519
+ func: async (contextName, namespace) => {
520
+ const agentName = await newAgentName(contextName, namespace);
521
+ installationPlan.addContext('agentName', agentName);
522
+ },
523
+ args: [kubeContextName, kubeNamespace],
524
+ condition: async () => !installationPlan.getContext('agentName'),
525
+ });
526
+
527
+ // create new agent
528
+ installationPlan.addStep({
529
+ name: 'create new agent',
530
+ func: async () => {
531
+ const agentName = installationPlan.getContext('agentName');
532
+ const agent = await sdk.agents.create({ name: agentName });
533
+ installationPlan.addContext('agent', agent);
534
+ const { token: agentToken } = agent;
535
+ console.log(`A Codefresh Runner with the name: ${colors.cyan(agentName)} has been created.`);
536
+ installationPlan.addContext('agentToken', agentToken);
537
+ },
538
+ installationEvent: installationProgress.events.AGENT_CREATED,
539
+ condition: async () => !installationPlan.getContext('agentToken'),
540
+ });
541
+
542
+ // install agent
543
+ installationPlan.addStep({
544
+ name: 'install new agent',
545
+ func: async () => {
546
+ await installAgent({
547
+ apiHost: sdk.config.context.url,
548
+ kubeContextName,
549
+ kubeNamespace,
550
+ token: installationPlan.getContext('agentToken'),
551
+ kubeNodeSelector,
552
+ tolerations,
553
+ kubeConfigPath,
554
+ dockerRegistry,
555
+ verbose,
556
+ agentId: installationPlan.getContext('agentName'),
557
+ envVars,
558
+ valuesFile, // --values
559
+ setValue, // --set-value
560
+ setFile, // --set-file
561
+ dryRun,
562
+ bypassDownload,
563
+ });
564
+ },
565
+ installationEvent: installationProgress.events.AGENT_INSTALLED,
566
+ executeOnDryRun: true,
567
+ condition: !shouldUseHelm,
568
+ });
569
+
570
+ // generate new runtime name
571
+ installationPlan.addContext('runtimeName', runtimeName ? runtimeName.trim() : runtimeName);
572
+ installationPlan.addStep({
573
+ name: 'generate new runtime name',
574
+ func: async (contextName, namespace) => {
575
+ const reName = await newRuntimeName(contextName, namespace);
576
+ installationPlan.addContext('runtimeName', reName);
577
+ },
578
+ args: [kubeContextName, kubeNamespace],
579
+ condition: async () => !installationPlan.getContext('runtimeName'),
580
+ });
581
+
582
+ // create new runtime
583
+ installationPlan.addStep({
584
+ name: 'create new runtime',
585
+ func: async () => {
586
+ const reName = installationPlan.getContext('runtimeName');
587
+ const runtimeCreateOpt = {
588
+ namespace: kubeNamespace,
589
+ storageClassName: storageClassName || `${INSTALLATION_DEFAULTS.STORAGE_CLASS_PREFIX}-${kubeNamespace}`,
590
+ serviceAccount: INSTALLATION_DEFAULTS.RUNTIME_SERVICE_ACCOUNT,
591
+ clusterName: kubeContextName,
592
+ runtimeEnvironmentName: reName,
593
+ agent: true,
594
+ dockerDaemonScheduler: {
595
+ userAccess: dockerDaemonAccess,
596
+ },
597
+ };
598
+
599
+ if (buildNodeSelector) {
600
+ runtimeCreateOpt.nodeSelector = keyValueAsStringToObject(buildNodeSelector);
601
+ }
602
+
603
+ await sdk.cluster.create(runtimeCreateOpt);
604
+ console.log(`Runtime environment "${colors.cyan(reName)}" has been created`);
605
+ },
606
+ });
607
+
608
+ // update runtime images with docker-registry
609
+ installationPlan.addStep({
610
+ name: 'update runtime environment images with docker-registry url',
611
+ func: async () => {
612
+ const reName = installationPlan.getContext('runtimeName');
613
+ const re = await sdk.runtimeEnvs.get({ name: reName });
614
+ const body = _.set({}, 'runtimeScheduler.envVars', getRuntimeImagesWithRegistryUrl(dockerRegistry));
615
+ _.set(body, 'runtimeScheduler.image', `${dockerRegistry}/codefresh/engine:master`);
616
+ _.set(body, 'dockerDaemonScheduler.dindImage', `${dockerRegistry}/codefresh/dind:18.09.5-v24-sp`);
617
+ await sdk.runtimeEnvs.update({ name: reName }, _.merge(re, body));
618
+ console.log(`Runtime environment "${colors.cyan(reName)}" has been updated with the specified docker-registry images`);
619
+ },
620
+ condition: !!dockerRegistry && dockerRegistry !== defaultDockerRegistry,
621
+ });
622
+
623
+ // update env vars
624
+ installationPlan.addStep({
625
+ name: 'update runtime environment with env vars and resources',
626
+ func: async () => {
627
+ const reName = installationPlan.getContext('runtimeName');
628
+ const re = await sdk.runtimeEnvs.get({ name: reName });
629
+
630
+ // update re env vars
631
+ if (envVars.length || reEnvVars) {
632
+ const envVarsObj = _.merge(keyValueArrayToObject(envVars), reEnvVars);
633
+
634
+ const currentEngineEnvVars = _.get(re, 'runtimeScheduler.envVars', {});
635
+ const currentDindEnvVars = _.get(re, 'dockerDaemonScheduler.envVars', {});
636
+ const newEngineEnvVars = _.merge(currentEngineEnvVars, envVarsObj);
637
+ const newDindEnvVars = _.merge(currentDindEnvVars, envVarsObj);
638
+
639
+ _.set(re, 'runtimeScheduler.envVars', newEngineEnvVars);
640
+ _.set(re, 'dockerDaemonScheduler.envVars', newDindEnvVars);
641
+ }
642
+
643
+ // update dind resources
644
+ if (reResources) {
645
+ _.set(re, 'dockerDaemonScheduler.defaultDindResources', reResources);
646
+ }
647
+
648
+ if (reTolerations) {
649
+ _.set(re, 'runtimeScheduler.tolerations', reTolerations);
650
+ _.set(re, 'dockerDaemonScheduler.tolerations', reTolerations);
651
+ }
652
+
653
+ if (userVolumeMounts) {
654
+ const currentdockerDaemonScheduler = _.get(re, 'dockerDaemonScheduler', {});
655
+ const newDockerDaemonScheduler = _.merge(currentdockerDaemonScheduler, { userVolumeMounts });
656
+ _.set(re, 'dockerDaemonScheduler', newDockerDaemonScheduler);
657
+ }
658
+
659
+ if (userVolumes) {
660
+ const currentdockerDaemonScheduler = _.get(re, 'dockerDaemonScheduler', {});
661
+ const newDockerDaemonScheduler = _.merge(currentdockerDaemonScheduler, { userVolumes });
662
+ _.set(re, 'dockerDaemonScheduler', newDockerDaemonScheduler);
663
+ }
664
+
665
+ await sdk.runtimeEnvs.update({ name: reName }, re);
666
+ console.log(`Runtime environment "${colors.cyan(reName)}" has been updated with env vars`);
667
+ },
668
+ condition: envVars.length || reResources || userVolumeMounts || userVolumes || reEnvVars,
669
+ });
670
+
671
+ // set runtime as default
672
+ installationPlan.addStep({
673
+ name: 'set new runtime as default',
674
+ func: async () => {
675
+ const reName = installationPlan.getContext('runtimeName');
676
+ const re = await sdk.runtimeEnvs.get({
677
+ name: reName,
678
+ });
679
+ await sdk.runtimeEnvs.setDefault({ account: re.accountId, name: re.metadata.name });
680
+ console.log(`Runtime environment "${colors.cyan(reName)}" has been set as the default runtime`);
681
+ },
682
+ condition: shouldMakeDefaultRe,
683
+ });
684
+
685
+ // add cluster integration
686
+ installationPlan.addStep({
687
+ name: 'add cluster integration',
688
+ func: async () => {
689
+ await createClusterCmd.handler({
690
+ 'kube-context': kubeContextName,
691
+ namespace: kubeNamespace,
692
+ 'behind-firewall': true,
693
+ serviceaccount: 'default',
694
+ terminateProcess: false,
695
+ });
696
+ },
697
+ installationEvent: installationProgress.events.CLUSTER_INTEGRATION_ADDED,
698
+ condition: async () => {
699
+ if (skipClusterIntegration) {
700
+ return false;
701
+ }
702
+ if (isInCluster()) {
703
+ console.log('Cluster integration was not added , please add it via codefresh "create clusters [name]"');
704
+ return false;
705
+ }
706
+ const clusters = await sdk.clusters.list() || [];
707
+ if (clusters.find(cluster => cluster.selector === kubeContextName)) {
708
+ return false; // cluster already exists
709
+ }
710
+ return true;
711
+ },
712
+ });
713
+
714
+ // install runtime on cluster
715
+ installationPlan.addStep({
716
+ name: 'install runtime',
717
+ func: async () => {
718
+ await installRuntime({
719
+ apiHost: sdk.config.context.url,
720
+ name: installationPlan.getContext('runtimeName'),
721
+ kubeContextName,
722
+ kubeNamespace,
723
+ token: sdk.config.context.token,
724
+ kubeConfigPath,
725
+ verbose,
726
+ kubeNodeSelector,
727
+ dockerRegistry,
728
+ envVars,
729
+ valuesFile,
730
+ setValue,
731
+ setFile,
732
+ storageClassName,
733
+ dryRun,
734
+ bypassDownload,
735
+ });
736
+ },
737
+ installationEvent: installationProgress.events.RUNTIME_INSTALLED,
738
+ executeOnDryRun: true,
739
+ condition: !shouldUseHelm,
740
+ });
741
+
742
+ // install app-proxy
743
+ installationPlan.addStep({
744
+ name: 'install app-proxy',
745
+ func: async () => {
746
+ await installAppProxy({
747
+ apiHost: sdk.config.context.url,
748
+ kubeContextName,
749
+ kubeNamespace,
750
+ verbose,
751
+ kubeConfigPath,
752
+ dockerRegistry,
753
+ envVars,
754
+ valuesFile,
755
+ setValue,
756
+ setFile,
757
+ bypassDownload,
758
+ appProxyHost,
759
+ appProxyIngressClass,
760
+ dryRun,
761
+ });
762
+ },
763
+ installationEvent: installationProgress.events.APP_PROXY_INSTALLED,
764
+ condition: !!appProxy && !shouldUseHelm,
765
+ executeOnDryRun: true,
766
+ });
767
+
768
+ // update runtime with ingress IP
769
+ installationPlan.addStep({
770
+ name: 'update runtime environment app proxy ip',
771
+ func: async () => {
772
+ const reName = installationPlan.getContext('runtimeName');
773
+ const re = await sdk.runtimeEnvs.get({ name: reName });
774
+ const body = {
775
+ appProxy: {
776
+ externalIP: `https://${appProxyHost}${appProxyPathPrefix || ''}`,
777
+ },
778
+ };
779
+ await sdk.runtimeEnvs.update({ name: reName }, _.merge(re, body));
780
+ console.log(`Runtime environment "${colors.cyan(reName)}" has been updated with the app proxy`);
781
+ },
782
+ condition: !!appProxy && !!appProxyHost,
783
+ });
784
+
785
+ // update agent with new runtime
786
+ installationPlan.addStep({
787
+ name: 'update agent with new runtime',
788
+ func: async () => {
789
+ const reName = installationPlan.getContext('runtimeName');
790
+ const agent = installationPlan.getContext('agent');
791
+ const rt = await sdk.runtimeEnvs.get({ name: reName });
792
+ if (!rt) {
793
+ throw new Error(`runtime ${reName} does not exist on the account`);
794
+ }
795
+ if (!rt.metadata.agent) {
796
+ throw new Error('cannot attach non hybrid runtime');
797
+ }
798
+ const runtimes = _.get(agent, 'runtimes', []);
799
+ const existingRT = _.find(runtimes, value => value === reName);
800
+ if (!existingRT) {
801
+ runtimes.push(reName);
802
+ await sdk.agents.update({ agentId: agent.id, runtimes });
803
+ }
804
+ },
805
+ installationEvent: installationProgress.events.AGENT_UPDATED,
806
+ });
807
+
808
+ // attach runtime to agent
809
+ installationPlan.addStep({
810
+ name: 'attach runtime to agent',
811
+ func: async () => {
812
+ await attachRuntime({
813
+ kubeContextName, // kube-context-name
814
+ kubeNamespace, // --kube-namespace
815
+ kubeConfigPath, // --kube-config-path
816
+ agentKubeContextName: kubeContextName, // --kube-context-name-agent
817
+ agentKubeNamespace: kubeNamespace, // --kube-namespace-agent
818
+ agentKubeConfigPath: kubeConfigPath, // --kube-config-path-agent
819
+ restartAgent: true, // --restart-agent
820
+ verbose, // --verbose
821
+ runtimeName: installationPlan.getContext('runtimeName'), // --runtimeName
822
+ dryRun,
823
+ bypassDownload,
824
+ valuesFile,
825
+ setValue,
826
+ setFile,
827
+ });
828
+ },
829
+ installationEvent: installationProgress.events.RUNNER_INSTALLED,
830
+ executeOnDryRun: true,
831
+ condition: !shouldUseHelm,
832
+ });
833
+
834
+
835
+ function shouldInstallMonitoringFn() {
836
+ if (!installMonitor) {
837
+ return false;
838
+ }
839
+
840
+ if (isInCluster() || skipClusterIntegration) {
841
+ console.log('Monitor component cannot be installed without cluster integration, you can install it seperately using: "codefresh install monitor"');
842
+ return false;
843
+ }
844
+
845
+ return true;
846
+ }
847
+
848
+ const userToken = _.get(sdk, 'config.context.token');
849
+
850
+ // install monitoring
851
+ installationPlan.addStep({
852
+ name: 'install cluster monitoring',
853
+ func: installMonitoring.handler,
854
+ arg: {
855
+ 'kube-config-path': kubeConfigPath,
856
+ 'cluster-id': kubeContextName,
857
+ 'kube-context-name': kubeContextName,
858
+ 'kube-namespace': kubeNamespace,
859
+ 'docker-registry': dockerRegistry,
860
+ 'env-vars': envVars,
861
+ 'set-value': setValue,
862
+ 'set-file': setFile,
863
+ 'dry-run': dryRun,
864
+ 'bypass-download': bypassDownload,
865
+ token: userToken,
866
+ verbose,
867
+ noExit: true, // to prevent if from calling inner: process.exit()
868
+ url,
869
+ values: valuesFile,
870
+ },
871
+ successMessage: 'Successfully installed cluster monitoring',
872
+ installationEvent: installationProgress.events.MONITOR_INSTALLED,
873
+ executeOnDryRun: true,
874
+ condition: !shouldUseHelm && shouldInstallMonitoringFn,
875
+ });
876
+
877
+ // helm value files if its enabled
878
+ installationPlan.addStep({
879
+ name: 'generate helm value files',
880
+ func: async () => {
881
+ const runtimeNameContext = installationPlan.getContext('runtimeName');
882
+ const agent = installationPlan.getContext('agent');
883
+
884
+ const keys = await produceVenonaKeys(kubeNamespace);
885
+
886
+ const _appProxy = {
887
+ enabled: appProxy || false,
888
+ host: appProxyHost || '',
889
+ };
890
+
891
+ const monitor = {
892
+ enabled: shouldInstallMonitoringFn(),
893
+ clusterId: kubeContextName,
894
+ token: userToken,
895
+ };
896
+
897
+ const global = {
898
+ namespace: kubeNamespace,
899
+ codefreshHost: sdk.config.context.url,
900
+ agentToken: agent.token,
901
+ agentId: agent.id,
902
+ agentName: agent.name,
903
+ accountId: agent.account,
904
+ runtimeName: runtimeNameContext,
905
+ codefreshToken: userToken,
906
+ keys,
907
+ };
908
+
909
+ const content = JSON.stringify({ appProxy: _appProxy, monitor, global }, null, 4);
910
+
911
+ fs.writeFileSync(
912
+ helmValuesFile,
913
+ content,
914
+ {
915
+ encoding: 'utf8',
916
+ },
917
+ );
918
+ },
919
+ condition: shouldUseHelm,
920
+ });
921
+
922
+ // Post Installation
923
+ if (shouldExecutePipeline) {
924
+ await addPipelineToInstallationPlan(installationPlan, dockerRegistry, !shouldUseHelm);
925
+ }
926
+
927
+ await installationPlan.execute();
928
+
929
+ if (!shouldUseHelm) {
930
+ console.log(colors.green('\nRunner Status:'));
931
+ await getAgents.handler({});
932
+ console.log('');
933
+ }
934
+
935
+ if (installMonitor) {
936
+ console.log(`Go to ${colors.blue('https://g.codefresh.io/kubernetes/services/')} to view your cluster in Codefresh dashbaord`);
937
+ }
938
+
939
+ console.log(`Link to the new runtime: ${colors.blue(`https://g.codefresh.io/account-admin/account-conf/runtime-environments?runtime=${encodeURI(installationPlan.getContext('runtimeName'))}`)}`);
940
+ console.log(`\nDocumentation link: ${colors.blue('https://codefresh.io/docs/docs/enterprise/codefresh-runner/#codefresh-runner-preview-release')}`);
941
+ console.log(`If you had any issues with the installation please report them at: ${colors.blue('https://github.com/codefresh-io/cli/issues/new')}`);
942
+ await to(progressReporter.report(installationProgress.events.FINISHED, installationProgress.status.SUCCESS));
943
+ await drawCodefreshFiglet();
944
+
945
+ if (shouldUseHelm) {
946
+ console.log(colors.blue('\nTo complete helm installation run: '));
947
+ console.log(' helm repo add cf-runtime https://chartmuseum.codefresh.io/cf-runtime');
948
+ console.log(` helm install cf-runtime cf-runtime/cf-runtime -f ${helmValuesFile} --create-namespace --namespace ${kubeNamespace}`);
949
+ console.log(colors.blue('\nIn order to test your runner helm based installation please execute:\n'));
950
+ console.log(` codefresh runner execute-test-pipeline --runtime-name ${installationPlan.getContext('runtimeName')}\n`);
951
+ }
952
+
953
+ process.exit(); // TODO : This is not needed - needed to be fixed
954
+ },
955
+ });
956
+
957
+ module.exports = initCmd;