@spinnaker/docker 2026.2.3 → 2026.3.0

package/src/pipeline/stages/bake/dockerBakeStage.spec.tsx

@@ -0,0 +1,187 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import {
+  AuthenticationService,
+  BakeExecutionLabel,
+  BakeryReader,
+  ExecutionDetailsTasks,
+  Registry,
+  SETTINGS,
+  Spinner,
+} from '@spinnaker/core';
+
+import {
+  applyDockerBakeStageDefaults,
+  DockerBakeExecutionDetails,
+  DockerBakeStageConfig,
+  DOCKER_BAKE_STAGE_CONFIG,
+} from './dockerBakeStage';
+
+describe('Docker bake stage', () => {
+  let originalBakeryDetailUrl: string;
+
+  beforeEach(() => {
+    originalBakeryDetailUrl = SETTINGS.bakeryDetailUrl;
+  });
+
+  beforeEach(() => Registry.reinitialize());
+  afterEach(() => {
+    SETTINGS.bakeryDetailUrl = originalBakeryDetailUrl;
+    Registry.reinitialize();
+  });
+
+  it('registers the package-local React stage config', () => {
+    Registry.pipeline.registerStage(DOCKER_BAKE_STAGE_CONFIG);
+
+    const stageConfig = Registry.pipeline.getStageConfig({ type: 'bake', cloudProvider: 'docker' } as any);
+
+    expect(stageConfig.provides).toBe('bake');
+    expect(stageConfig.cloudProvider).toBe('docker');
+    expect(stageConfig.component).toBe(DockerBakeStageConfig);
+    expect(stageConfig.executionDetailsSections).toEqual([DockerBakeExecutionDetails, ExecutionDetailsTasks]);
+    expect(stageConfig.executionLabelComponent).toBe(BakeExecutionLabel);
+  });
+
+  it('applies Docker bake defaults and removes empty string properties', () => {
+    const stage: any = {
+      package: 'my-package',
+      organization: '',
+      extendedAttributes: {},
+    };
+
+    const result = applyDockerBakeStageDefaults(stage, {
+      user: 'user@example.com',
+      baseOsOptions: [{ id: 'ubuntu' }, { id: 'debian' }],
+      baseLabelOptions: ['release', 'snapshot'],
+    });
+
+    expect(result).toEqual({
+      package: 'my-package',
+      extendedAttributes: {},
+      region: 'global',
+      user: 'user@example.com',
+      baseOs: 'ubuntu',
+      baseLabel: 'release',
+    });
+    expect(result).not.toBe(stage);
+  });
+
+  it('keeps existing Docker bake values when defaults are available', () => {
+    const stage: any = {
+      region: 'custom-region',
+      user: 'existing-user',
+      baseOs: 'debian',
+      baseLabel: 'snapshot',
+    };
+
+    const result = applyDockerBakeStageDefaults(stage, {
+      user: 'user@example.com',
+      baseOsOptions: [{ id: 'ubuntu' }],
+      baseLabelOptions: ['release'],
+    });
+
+    expect(result.region).toBe('custom-region');
+    expect(result.user).toBe('existing-user');
+    expect(result.baseOs).toBe('debian');
+    expect(result.baseLabel).toBe('snapshot');
+  });
+
+  it('persists Docker bake defaults after loading options', async () => {
+    spyOn(AuthenticationService, 'getAuthenticatedUser').and.returnValue({ name: 'user@example.com' } as any);
+    spyOn(BakeryReader, 'getBaseOsOptions').and.returnValue(Promise.resolve({ baseImages: [{ id: 'ubuntu' }] } as any));
+    spyOn(BakeryReader, 'getBaseLabelOptions').and.returnValue(Promise.resolve(['release']));
+
+    const updateStage = jasmine.createSpy('updateStage');
+
+    shallow(
+      <DockerBakeStageConfig
+        application={{} as any}
+        pipeline={{} as any}
+        stage={{ package: 'my-package', organization: '' } as any}
+        stageFieldUpdated={jasmine.createSpy('stageFieldUpdated')}
+        updateStage={updateStage}
+        updateStageField={jasmine.createSpy('updateStageField')}
+      />,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(updateStage).toHaveBeenCalledWith({
+      package: 'my-package',
+      region: 'global',
+      user: 'user@example.com',
+      baseOs: 'ubuntu',
+      baseLabel: 'release',
+    });
+  });
+
+  it('shows an error instead of a permanent spinner when bake options fail to load', async () => {
+    spyOn(BakeryReader, 'getBaseOsOptions').and.returnValue(Promise.reject(new Error('boom')));
+    spyOn(BakeryReader, 'getBaseLabelOptions').and.returnValue(Promise.resolve(['release']));
+
+    const wrapper = shallow(
+      <DockerBakeStageConfig
+        application={{} as any}
+        pipeline={{} as any}
+        stage={{ package: 'my-package' } as any}
+        stageFieldUpdated={jasmine.createSpy('stageFieldUpdated')}
+        updateStage={jasmine.createSpy('updateStage')}
+        updateStageField={jasmine.createSpy('updateStageField')}
+      />,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    wrapper.update();
+
+    expect(wrapper.find(Spinner).exists()).toBe(false);
+    expect(wrapper.text()).toContain('Unable to load Docker bake options');
+  });
+
+  it('does not update state after unmounting before bake options load', async () => {
+    let resolveBaseOsOptions: (value: any) => void;
+    let resolveBaseLabelOptions: (value: string[]) => void;
+    spyOn(BakeryReader, 'getBaseOsOptions').and.returnValue(new Promise((resolve) => (resolveBaseOsOptions = resolve)));
+    spyOn(BakeryReader, 'getBaseLabelOptions').and.returnValue(
+      new Promise((resolve) => (resolveBaseLabelOptions = resolve)),
+    );
+
+    const wrapper = shallow(
+      <DockerBakeStageConfig
+        application={{} as any}
+        pipeline={{} as any}
+        stage={{ package: 'my-package' } as any}
+        stageFieldUpdated={jasmine.createSpy('stageFieldUpdated')}
+        updateStage={jasmine.createSpy('updateStage')}
+        updateStageField={jasmine.createSpy('updateStageField')}
+      />,
+    );
+    const setState = spyOn(wrapper.instance() as DockerBakeStageConfig, 'setState');
+
+    wrapper.unmount();
+    resolveBaseOsOptions!({ baseImages: [{ id: 'ubuntu' }] });
+    resolveBaseLabelOptions!(['release']);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(setState).not.toHaveBeenCalled();
+  });
+
+  it('replaces every bakery detail URL placeholder occurrence', () => {
+    SETTINGS.bakeryDetailUrl =
+      '/bakery/{{context.region}}/{{context.region}}/{{context.status.resourceId}}/{{context.status.resourceId}}';
+
+    const wrapper = shallow(
+      <DockerBakeExecutionDetails
+        current={true}
+        name="bakeConfig"
+        stage={
+          {
+            context: { region: 'us-west-2', status: { resourceId: 'image-123' } },
+          } as any
+        }
+      />,
+    );
+
+    expect(wrapper.find('a').prop('href')).toBe('/bakery/us-west-2/us-west-2/image-123/image-123');
+  });
+});

package/src/pipeline/stages/bake/dockerBakeStage.tsx

@@ -0,0 +1,313 @@
+import { isEqual } from 'lodash';
+import React from 'react';
+
+import type {
+  IExecutionDetailsSectionProps,
+  IFormikStageConfigInjectedProps,
+  IStage,
+  IStageConfigProps,
+} from '@spinnaker/core';
+import {
+  AuthenticationService,
+  BakeExecutionLabel,
+  BakeryReader,
+  ExecutionDetailsSection,
+  ExecutionDetailsTasks,
+  FormikStageConfig,
+  Registry,
+  SETTINGS,
+  Spinner,
+  StageConfigField,
+  StageFailureMessage,
+} from '@spinnaker/core';
+
+interface IBaseOsOption {
+  id: string;
+  shortDescription?: string;
+  detailedDescription?: string;
+  isImageFamily?: boolean;
+  displayName?: string;
+}
+
+interface IDockerBakeStageDefaults {
+  user: string;
+  baseOsOptions: IBaseOsOption[];
+  baseLabelOptions: string[];
+}
+
+interface IDockerBakeStageConfigState {
+  baseLabelOptions: string[];
+  baseOsOptions: IBaseOsOption[];
+  loadError: boolean;
+  loading: boolean;
+}
+
+function deleteEmptyProperties(stage: IStage): IStage {
+  return Object.keys(stage).reduce((acc, key) => {
+    if ((stage as any)[key] !== '') {
+      (acc as any)[key] = (stage as any)[key];
+    }
+    return acc;
+  }, {} as IStage);
+}
+
+export function applyDockerBakeStageDefaults(stage: IStage, defaults: IDockerBakeStageDefaults): IStage {
+  const nextStage = deleteEmptyProperties({ ...stage });
+
+  nextStage.region = nextStage.region || 'global';
+  nextStage.user = nextStage.user || defaults.user;
+
+  if (!nextStage.baseOs && defaults.baseOsOptions?.length) {
+    nextStage.baseOs = defaults.baseOsOptions[0].id;
+  }
+
+  if (!nextStage.baseLabel && defaults.baseLabelOptions?.length) {
+    nextStage.baseLabel = defaults.baseLabelOptions[0];
+  }
+
+  return nextStage;
+}
+
+function baseOsDescription(baseOsOption: IBaseOsOption): string {
+  const baseOsName = baseOsOption?.displayName || baseOsOption?.id || '';
+  return baseOsOption?.shortDescription ? `${baseOsName} (${baseOsOption.shortDescription})` : baseOsName;
+}
+
+function bakeryDetailUrl(stage: IStage): string {
+  const context = stage.context || {};
+  const urlTemplate = SETTINGS.bakeryDetailUrl || '';
+  return urlTemplate
+    .replace(/\{\{context\.region\}\}/g, context.region || '')
+    .replace(/\{\{context\.status\.resourceId\}\}/g, context.status?.resourceId || '');
+}
+
+function DockerBakeStageForm({
+  baseLabelOptions,
+  baseOsOptions,
+  formik,
+}: IFormikStageConfigInjectedProps & IDockerBakeStageConfigState) {
+  const stage = formik.values;
+  const extendedAttributes = stage.extendedAttributes || {};
+  const setFieldValue = (field: string) => (event: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => {
+    formik.setFieldValue(field, event.target.value);
+  };
+
+  return (
+    <>
+      <StageConfigField label="Package" helpKey="pipeline.config.bake.package">
+        <input
+          type="text"
+          className="form-control input-sm"
+          value={stage.package || ''}
+          onChange={setFieldValue('package')}
+        />
+      </StageConfigField>
+      <StageConfigField label="Organization" helpKey="pipeline.config.docker.bake.organization">
+        <input
+          type="text"
+          className="form-control input-sm"
+          value={stage.organization || ''}
+          onChange={setFieldValue('organization')}
+        />
+      </StageConfigField>
+      <StageConfigField label="Image Name" helpKey="pipeline.config.docker.bake.targetImage">
+        <input
+          type="text"
+          className="form-control input-sm"
+          value={stage.ami_name || ''}
+          onChange={setFieldValue('ami_name')}
+        />
+      </StageConfigField>
+      <StageConfigField label="Image tag" helpKey="pipeline.config.docker.bake.targetImageTag">
+        <input
+          type="text"
+          className="form-control input-sm"
+          value={extendedAttributes.docker_target_image_tag || ''}
+          onChange={setFieldValue('extendedAttributes.docker_target_image_tag')}
+        />
+      </StageConfigField>
+      <StageConfigField label="Base OS">
+        <select className="form-control input-sm" value={stage.baseOs || ''} onChange={setFieldValue('baseOs')}>
+          {baseOsOptions.map((baseOsOption: IBaseOsOption) => (
+            <option key={baseOsOption.id} value={baseOsOption.id}>
+              {baseOsDescription(baseOsOption)}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      <StageConfigField label="Base Label">
+        {baseLabelOptions.map((baseLabel: string) => (
+          <label key={baseLabel} className="radio-inline">
+            <input
+              type="radio"
+              checked={stage.baseLabel === baseLabel}
+              onChange={() => formik.setFieldValue('baseLabel', baseLabel)}
+            />
+            {baseLabel}
+          </label>
+        ))}
+      </StageConfigField>
+      <StageConfigField label="Rebake">
+        <div className="checkbox" style={{ marginBottom: 0 }}>
+          <label>
+            <input
+              type="checkbox"
+              checked={!!stage.rebake}
+              onChange={(event) => formik.setFieldValue('rebake', event.target.checked)}
+            />
+            Rebake image without regard to the status of any existing bake
+          </label>
+        </div>
+      </StageConfigField>
+    </>
+  );
+}
+
+export class DockerBakeStageConfig extends React.Component<IStageConfigProps, IDockerBakeStageConfigState> {
+  private mounted = false;
+
+  public state: IDockerBakeStageConfigState = {
+    baseLabelOptions: [],
+    baseOsOptions: [],
+    loadError: false,
+    loading: true,
+  };
+
+  public componentDidMount(): void {
+    this.mounted = true;
+    Promise.all([BakeryReader.getBaseOsOptions('docker'), BakeryReader.getBaseLabelOptions()])
+      .then(([baseOsOptions, baseLabelOptions]) => {
+        if (!this.mounted) {
+          return;
+        }
+
+        const baseOsOptionsList = baseOsOptions.baseImages || [];
+        const stageWithDefaults = applyDockerBakeStageDefaults(this.props.stage, {
+          user: AuthenticationService.getAuthenticatedUser()?.name,
+          baseOsOptions: baseOsOptionsList,
+          baseLabelOptions,
+        });
+
+        if (!isEqual(stageWithDefaults, this.props.stage)) {
+          this.props.updateStage(stageWithDefaults);
+        }
+
+        this.setState({
+          baseLabelOptions,
+          baseOsOptions: baseOsOptionsList,
+          loadError: false,
+          loading: false,
+        });
+      })
+      .catch(() => {
+        if (!this.mounted) {
+          return;
+        }
+
+        this.setState({ loadError: true, loading: false });
+      });
+  }
+
+  public componentWillUnmount(): void {
+    this.mounted = false;
+  }
+
+  public render() {
+    if (this.state.loading) {
+      return <Spinner />;
+    }
+
+    if (this.state.loadError) {
+      return <div className="alert alert-danger">Unable to load Docker bake options.</div>;
+    }
+
+    const authenticatedUser = AuthenticationService.getAuthenticatedUser();
+    const stageWithDefaults = applyDockerBakeStageDefaults(this.props.stage, {
+      user: authenticatedUser?.name,
+      baseOsOptions: this.state.baseOsOptions,
+      baseLabelOptions: this.state.baseLabelOptions,
+    });
+
+    return (
+      <FormikStageConfig
+        application={this.props.application}
+        onChange={this.props.updateStage}
+        pipeline={this.props.pipeline}
+        stage={stageWithDefaults}
+        render={(props: IFormikStageConfigInjectedProps) => <DockerBakeStageForm {...props} {...this.state} />}
+      />
+    );
+  }
+}
+
+export function DockerBakeExecutionDetails(props: IExecutionDetailsSectionProps) {
+  const { current, name, stage } = props;
+  const context = stage.context || {};
+  const resourceId = context.status?.resourceId;
+
+  return (
+    <ExecutionDetailsSection name={name} current={current}>
+      <div className="row">
+        <div className="col-md-6">
+          <dl className="dl-narrow dl-horizontal">
+            <dt>Organization</dt>
+            <dd>{context.organization}</dd>
+            <dt>Image Name</dt>
+            <dd>{context.ami_name}</dd>
+            <dt>Image Tag</dt>
+            <dd>{context.extendedAttributes?.docker_target_image_tag}</dd>
+            <dt>Image</dt>
+            <dd>{context.ami}</dd>
+          </dl>
+        </div>
+        <div className="col-md-6">
+          <dl className="dl-narrow dl-horizontal">
+            <dt>Base OS</dt>
+            <dd>{context.baseOs}</dd>
+            <dt>Region</dt>
+            <dd>{context.region}</dd>
+            <dt>Package</dt>
+            <dd>{context.package}</dd>
+            <dt>Label</dt>
+            <dd>{context.baseLabel}</dd>
+          </dl>
+        </div>
+      </div>
+      <StageFailureMessage stage={stage} message={stage.failureMessage} />
+      {context.region && resourceId && (
+        <div className="row">
+          <div className="col-md-12">
+            <div className={`alert alert-${stage.isFailed ? 'danger' : 'info'}`}>
+              <a target="_blank" rel="noopener noreferrer" href={bakeryDetailUrl(stage)}>
+                View Bakery Details
+              </a>
+            </div>
+          </div>
+        </div>
+      )}
+    </ExecutionDetailsSection>
+  );
+}
+
+(DockerBakeExecutionDetails as any).title = 'bakeConfig';
+
+export const DOCKER_BAKE_STAGE_CONFIG: any = {
+  provides: 'bake',
+  cloudProvider: 'docker',
+  label: 'Bake',
+  description: 'Bakes an image',
+  component: DockerBakeStageConfig,
+  executionDetailsSections: [DockerBakeExecutionDetails as any, ExecutionDetailsTasks],
+  executionLabelComponent: BakeExecutionLabel,
+  extraLabelLines: (stage: IStage) => {
+    return (stage as any).masterStage.context.allPreviouslyBaked ||
+      (stage as any).masterStage.context.somePreviouslyBaked
+      ? 1
+      : 0;
+  },
+  supportsCustomTimeout: true,
+  validators: [{ type: 'requiredField', fieldName: 'package' }],
+  restartable: true,
+};
+
+Registry.pipeline.registerStage(DOCKER_BAKE_STAGE_CONFIG);

package/src/pipeline/trigger/DockerTrigger.tsx

@@ -45,8 +45,8 @@ Registry.pipeline.registerTrigger({
 });
 
 Registry.pipeline.registerTrigger({
-  label: 'Helm Docker Registry',
-  description: 'Executes the pipeline on an helm/image update',
+  label: 'Docker Registry (OCI)',
+  description: 'Executes the pipeline on a Docker OCI image update',
   key: 'helm/oci',
   component: DockerHelmOciTriggerConfig,
   manualExecutionComponent: DockerTriggerTemplate,

package/src/pipeline/trigger/DockerTriggerTemplate.spec.tsx

@@ -0,0 +1,124 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { DockerTriggerTemplate } from './DockerTriggerTemplate';
+import { DockerImageReader } from '../../image';
+
+interface IDeferred<T> {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+}
+
+function deferred<T>(): IDeferred<T> {
+  let resolve: (value: T) => void;
+  const promise = new Promise<T>((promiseResolve) => (resolve = promiseResolve));
+  return { promise, resolve };
+}
+
+describe('<DockerTriggerTemplate/>', () => {
+  it('formats Docker trigger labels', async () => {
+    await expectAsync(
+      Promise.resolve(
+        DockerTriggerTemplate.formatLabel({ account: 'prod-registry', repository: 'example/service' } as any),
+      ),
+    ).toBeResolvedTo('(Docker Registry) prod-registry: example/service');
+  });
+
+  it('writes docker image artifacts using tag references', () => {
+    const updateCommand = jasmine.createSpy('updateCommand');
+    const component = new DockerTriggerTemplate({
+      command: {
+        trigger: {
+          type: 'docker',
+          registry: 'registry.example.com',
+          repository: 'example/service',
+        },
+      },
+      updateCommand,
+    } as any);
+
+    (component as any).updateArtifact((component.props as any).command, '1.260101.000000-0000000');
+
+    expect(updateCommand).toHaveBeenCalledWith('extraFields.tag', '1.260101.000000-0000000');
+    expect(updateCommand).toHaveBeenCalledWith('extraFields.artifacts', [
+      {
+        type: 'docker/image',
+        name: 'registry.example.com/example/service',
+        version: '1.260101.000000-0000000',
+        reference: 'registry.example.com/example/service:1.260101.000000-0000000',
+      },
+    ]);
+  });
+
+  it('writes Helm OCI image artifacts using digest references', () => {
+    const updateCommand = jasmine.createSpy('updateCommand');
+    const component = new DockerTriggerTemplate({
+      command: {
+        trigger: {
+          type: 'helm/oci',
+          registry: 'registry.example.com',
+          repository: 'charts/service',
+        },
+      },
+      updateCommand,
+    } as any);
+    (component as any).state.lookupType = 'digest';
+
+    (component as any).updateArtifact((component.props as any).command, 'sha256:abc123');
+
+    expect(updateCommand).toHaveBeenCalledWith('extraFields.tag', 'sha256:abc123');
+    expect(updateCommand).toHaveBeenCalledWith('extraFields.artifacts', [
+      {
+        type: 'helm/image',
+        name: 'registry.example.com/charts/service',
+        version: 'sha256:abc123',
+        reference: 'registry.example.com/charts/service@sha256:abc123',
+      },
+    ]);
+  });
+  it('aborts superseded and unmounted tag queries without publishing cancellation errors', async () => {
+    jasmine.clock().install();
+    try {
+      const firstRequest = deferred<string[]>();
+      const secondRequest = deferred<string[]>();
+      const findTags = spyOn(DockerImageReader, 'findTags').and.returnValues(
+        firstRequest.promise,
+        secondRequest.promise,
+      );
+      const wrapper = shallow(
+        <DockerTriggerTemplate
+          command={{
+            trigger: { type: 'docker', repository: 'example/service' },
+          }}
+          updateCommand={jasmine.createSpy('updateCommand')}
+        />,
+        { disableLifecycleMethods: true },
+      );
+      const component = wrapper.instance() as DockerTriggerTemplate;
+      const tagLoadSuccess = spyOn(component as any, 'tagLoadSuccess').and.callThrough();
+      const tagLoadFailure = spyOn(component as any, 'tagLoadFailure').and.callThrough();
+
+      (component as any).initialize();
+      jasmine.clock().tick(250);
+      (component as any).searchTags();
+      jasmine.clock().tick(250);
+      const firstSignal = findTags.calls.argsFor(0)[1] as AbortSignal;
+      const secondSignal = findTags.calls.argsFor(1)[1] as AbortSignal;
+
+      expect(firstSignal.aborted).toBe(true);
+      expect(secondSignal.aborted).toBe(false);
+      wrapper.unmount();
+      expect(secondSignal.aborted).toBe(true);
+
+      firstRequest.resolve(['stale']);
+      secondRequest.resolve(['late']);
+      await Promise.all([firstRequest.promise, secondRequest.promise]);
+      await Promise.resolve();
+
+      expect(tagLoadSuccess).not.toHaveBeenCalled();
+      expect(tagLoadFailure).not.toHaveBeenCalled();
+    } finally {
+      jasmine.clock().uninstall();
+    }
+  });
+});