feat: add global builder engine default

src/server/lib/buildEngines.ts

@@ -0,0 +1,9 @@
+export const NATIVE_BUILDER_ENGINES = ['buildkit', 'kaniko'] as const;
+export const BUILDER_ENGINES = [...NATIVE_BUILDER_ENGINES, 'ci'] as const;
+
+export type NativeBuilderEngine = (typeof NATIVE_BUILDER_ENGINES)[number];
+export type BuilderEngine = (typeof BUILDER_ENGINES)[number];
+
+export function isNativeBuilderEngine(engine: unknown): engine is NativeBuilderEngine {
+  return NATIVE_BUILDER_ENGINES.includes(engine as NativeBuilderEngine);
+}

src/server/lib/config/ConfigBuilder.ts

@@ -20,6 +20,7 @@ import {
   NativeHelmConfig as GlobalNativeHelmConfig,
   NativeHelmPostRendererConfig as GlobalNativeHelmPostRendererConfig,
 } from 'server/services/types/globalConfig';
+import { BuilderEngine } from 'server/lib/buildEngines';
 
 export type HelmPostRendererConfig = GlobalNativeHelmPostRendererConfig;
 export type NativeHelmConfig = Partial<GlobalNativeHelmConfig>;
@@ -39,7 +40,7 @@ export interface HelmConfig {
 }
 
 export interface BuildConfig {
-  engine?: 'buildkit' | 'kaniko';
+  engine?: BuilderEngine;
   serviceAccount?: string;
   jobTimeout?: number;
   resources?: {
@@ -171,7 +172,7 @@ export class HelmConfigBuilder extends ConfigBuilder<HelmConfig> {
 }
 
 export class BuildConfigBuilder extends ConfigBuilder<BuildConfig> {
-  setEngine(engine: 'buildkit' | 'kaniko'): BuildConfigBuilder {
+  setEngine(engine: BuilderEngine): BuildConfigBuilder {
     this.set('engine', engine);
     return this;
   }

src/server/lib/config/__tests__/ConfigBuilder.test.ts

@@ -142,6 +142,12 @@ describe('ConfigBuilder', () => {
         endpoint: 'tcp://buildkit-custom:1234',
       });
     });
+
+    it('sets ci as an explicit build engine', () => {
+      const config = new BuildConfigBuilder().setEngine('ci').build();
+
+      expect(config.engine).toBe('ci');
+    });
   });
 
   describe('GlobalConfigBuilder', () => {

src/server/lib/helm/__tests__/helm.test.ts

@@ -336,7 +336,7 @@ describe('Helm tests', () => {
           buildUUID: 'build-123',
           port: 8080,
           builder: {
-            engine: 'docker',
+            engine: 'ci',
           },
           helm: {
             chart: { name: 'lifecycle-app', values: [] },

src/server/lib/jsonschema/schemas/1.0.0.json

@@ -376,7 +376,12 @@
                     "additionalProperties": true,
                     "properties": {
                       "engine": {
-                        "type": "string"
+                        "type": "string",
+                        "enum": [
+                          "buildkit",
+                          "kaniko",
+                          "ci"
+                        ]
                       },
                       "resources": {
                         "type": "object",
@@ -809,7 +814,12 @@
                     "additionalProperties": true,
                     "properties": {
                       "engine": {
-                        "type": "string"
+                        "type": "string",
+                        "enum": [
+                          "buildkit",
+                          "kaniko",
+                          "ci"
+                        ]
                       },
                       "resources": {
                         "type": "object",

src/server/lib/nativeBuild/index.ts

@@ -19,6 +19,7 @@ import { getLogger, withSpan, withLogContext } from '../logger';
 import { ensureNamespaceExists } from './utils';
 import { buildWithEngine, NativeBuildOptions } from './engines';
 import { ensureServiceAccountForJob } from '../kubernetes/common/serviceAccount';
+import { isNativeBuilderEngine } from '../buildEngines';
 
 export type { NativeBuildOptions } from './engines';
 
@@ -51,7 +52,7 @@ export async function buildWithNative(deploy: Deploy, options: NativeBuildOption
 
           let result: NativeBuildResult;
 
-          if (builderEngine === 'buildkit' || builderEngine === 'kaniko') {
+          if (isNativeBuilderEngine(builderEngine)) {
             getLogger().debug(`Build: using ${builderEngine} engine`);
             result = await buildWithEngine(deploy, buildOptions, builderEngine);
           } else {

src/server/lib/nativeHelm/__tests__/helm.test.ts

@@ -953,7 +953,7 @@ describe('Native Helm', () => {
           buildUUID: 'build-123',
           port: 8080,
           builder: {
-            engine: 'docker',
+            engine: 'ci',
           },
           helm: {
             chart: { name: 'lifecycle-app', values: [] },

src/server/lib/yamlSchemas/schema_1_0_0/docker.ts

@@ -25,7 +25,7 @@ export const docker = {
       type: 'object',
       additionalProperties: true,
       properties: {
-        engine: { type: 'string' },
+        engine: { type: 'string', enum: ['buildkit', 'kaniko', 'ci'] },
         resources: {
           type: 'object',
           additionalProperties: false,

src/server/models/yaml/YamlService.ts

@@ -21,6 +21,7 @@ import GlobalConfigService from 'server/services/globalConfig';
 import { DeployTypes, FeatureFlags, NO_DEFAULT_ENV_UUID } from 'shared/constants';
 import Build from '../Build';
 import { DomainDefaults, NativeHelmConfig } from 'server/services/types/globalConfig';
+import { BuilderEngine } from 'server/lib/buildEngines';
 
 export interface Service001 {
   readonly github: {
@@ -291,7 +292,7 @@ export interface ServiceDiskConfig {
 }
 
 export interface Builder {
-  readonly engine?: string;
+  readonly engine?: BuilderEngine;
   readonly resources?: {
     readonly requests?: Record<string, string>;
     readonly limits?: Record<string, string>;
@@ -413,6 +414,19 @@ export function hasLifecycleManagedDockerBuild(service: Service): boolean {
   }
 }
 
+export function getEffectiveBuilder(service: Service, defaultEngine?: BuilderEngine): Builder {
+  const builder = getBuilder(service) ?? {};
+
+  if (builder.engine || !defaultEngine || !hasLifecycleManagedDockerBuild(service)) {
+    return builder;
+  }
+
+  return {
+    ...builder,
+    engine: defaultEngine,
+  };
+}
+
 /**
  * Helper function to quickly retrieve the environment variables from varies Lifecycle service type (because they are in different locations within the JSON structure).
  * @param service Valid Lifecycle Service YAML model

src/server/services/__tests__/deploy.test.ts

@@ -23,6 +23,14 @@ import * as github from 'server/lib/github';
 mockRedisClient();
 
 const mockCliDeploy = jest.fn();
+const mockCodefreshBuildImage = jest.fn();
+const mockCodefreshGetLogs = jest.fn();
+const mockCodefreshGetRepositoryTag = jest.fn();
+const mockCodefreshTagExists = jest.fn();
+const mockCodefreshWaitForImage = jest.fn();
+const mockBuildWithNative = jest.fn();
+const mockGlobalConfigGetAllConfigs = jest.fn();
+const mockGlobalConfigGetOrgChartName = jest.fn();
 
 jest.mock('server/lib/logger', () => ({
   getLogger: jest.fn(() => ({
@@ -41,11 +49,24 @@ jest.mock('server/services/globalConfig', () => ({
   __esModule: true,
   default: {
     getInstance: jest.fn(() => ({
-      getOrgChartName: jest.fn().mockResolvedValue('org-chart'),
+      getAllConfigs: (...args: any[]) => mockGlobalConfigGetAllConfigs(...args),
+      getOrgChartName: (...args: any[]) => mockGlobalConfigGetOrgChartName(...args),
     })),
   },
 }));
 
+jest.mock('server/lib/codefresh', () => ({
+  buildImage: (...args: any[]) => mockCodefreshBuildImage(...args),
+  getLogs: (...args: any[]) => mockCodefreshGetLogs(...args),
+  getRepositoryTag: (...args: any[]) => mockCodefreshGetRepositoryTag(...args),
+  tagExists: (...args: any[]) => mockCodefreshTagExists(...args),
+  waitForImage: (...args: any[]) => mockCodefreshWaitForImage(...args),
+}));
+
+jest.mock('server/lib/nativeBuild', () => ({
+  buildWithNative: (...args: any[]) => mockBuildWithNative(...args),
+}));
+
 const mockDetermineChartType = jest.fn();
 jest.mock('server/lib/nativeHelm', () => ({
   ...jest.requireActual('server/lib/nativeHelm'),
@@ -91,6 +112,25 @@ describe('DeployService - shouldTriggerGithubDeployment', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     mockCliDeploy.mockReset();
+    mockCodefreshBuildImage.mockReset();
+    mockCodefreshGetLogs.mockReset();
+    mockCodefreshGetRepositoryTag.mockReset();
+    mockCodefreshTagExists.mockReset();
+    mockCodefreshWaitForImage.mockReset();
+    mockBuildWithNative.mockReset();
+    mockGlobalConfigGetOrgChartName.mockResolvedValue('org-chart');
+    mockGlobalConfigGetAllConfigs.mockResolvedValue({
+      lifecycleDefaults: {
+        buildPipeline: 'sample/build-image',
+        deployCluster: 'test-cluster',
+        ecrDomain: '123456789012.dkr.ecr.us-west-2.amazonaws.com',
+        ecrRegistry: 'sample-registry',
+      },
+      app_setup: {
+        org: 'example-org',
+      },
+      buildDefaults: {},
+    });
     mockDetermineChartType.mockResolvedValue(ChartType.PUBLIC);
 
     mockDb = {
@@ -352,6 +392,75 @@ describe('DeployService - shouldTriggerGithubDeployment', () => {
       );
     });
 
+    test('buildImageForHelmAndGithub uses Codefresh when builder engine is ci', async () => {
+      (github.getSHAForBranch as jest.Mock).mockResolvedValue('abcdef1234567890');
+      mockCodefreshTagExists.mockResolvedValue(false);
+      mockCodefreshBuildImage.mockResolvedValue('codefresh-build-123');
+      mockCodefreshWaitForImage.mockResolvedValue(false);
+      mockCodefreshGetLogs.mockResolvedValue('codefresh logs');
+      const patchSpy = jest.spyOn(deployService, 'patchAndUpdateActivityFeed').mockResolvedValue(undefined);
+      const deployPatch = jest.fn().mockResolvedValue(undefined);
+      const deploy = {
+        uuid: 'sample-service-build',
+        runUUID: 'run-1',
+        branchName: 'feature-branch',
+        env: {},
+        initEnv: {},
+        dockerImage: 'old-image',
+        service: {
+          name: 'sample-service',
+        },
+        build: {
+          id: 1,
+          uuid: 'sample-build',
+          namespace: 'env-sample',
+          enableFullYaml: true,
+          commentRuntimeEnv: {},
+          enabledFeatures: [],
+          pullRequest: {
+            githubLogin: 'sample-user',
+          },
+          $fetchGraph: jest.fn().mockResolvedValue(undefined),
+        },
+        deployable: {
+          name: 'sample-service',
+          type: DeployTypes.GITHUB,
+          dockerfilePath: './Dockerfile',
+          initDockerfilePath: null,
+          env: {},
+          ecr: 'sample/app-images',
+          dockerBuildPipelineName: 'sample/build-image',
+          builder: {
+            engine: 'ci',
+          },
+          repository: {
+            fullName: 'example-org/example-repo',
+          },
+          $fetchGraph: jest.fn().mockResolvedValue(undefined),
+        },
+        reload: jest.fn().mockResolvedValue(undefined),
+        $query: jest.fn(() => ({
+          patch: deployPatch,
+        })),
+      };
+
+      const result = await deployService.buildImageForHelmAndGithub(deploy as any, 'run-1');
+
+      expect(result).toBe(false);
+      expect(mockBuildWithNative).not.toHaveBeenCalled();
+      expect(mockCodefreshBuildImage).toHaveBeenCalledTimes(1);
+      expect(mockCodefreshBuildImage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          buildPipelineName: 'sample/build-image',
+          dockerfilePath: './Dockerfile',
+          repo: 'example-org/example-repo',
+        })
+      );
+      expect(deployPatch).toHaveBeenCalledWith({ buildPipelineId: 'codefresh-build-123' });
+      expect(deployPatch).toHaveBeenCalledWith({ buildOutput: 'codefresh logs' });
+      expect(patchSpy).toHaveBeenLastCalledWith(deploy, { status: DeployStatus.BUILD_FAILED }, 'run-1');
+    });
+
     test('deployAurora records failures with the newly assigned runUUID', async () => {
       const patchSpy = jest.spyOn(deployService, 'patchAndUpdateActivityFeed').mockResolvedValue(undefined);
       jest.spyOn(deployService as any, 'findExistingAuroraDatabase').mockResolvedValue(null);