@spinnaker/core 0.24.1 → 0.25.0

package/dist/manifest/ManifestYaml.d.ts

@@ -1,7 +1,13 @@
 /// <reference types="react" />
-export interface IManifestYamlProps {
+declare type IManifestYamlProps = {
     linkName: string;
-    manifestText: string;
     modalTitle: string;
-}
-export declare function ManifestYaml(props: IManifestYamlProps): JSX.Element;
+} & ({
+    manifestText: string;
+    manifestUri?: never;
+} | {
+    manifestText?: never;
+    manifestUri: string;
+});
+export declare function ManifestYaml({ linkName, modalTitle, manifestText, manifestUri }: IManifestYamlProps): JSX.Element;
+export {};

package/dist/pipeline/config/stages/bakeManifest/ManifestRenderers.d.ts

@@ -1,8 +1,10 @@
 export declare enum ManifestRenderers {
     HELM2 = "HELM2",
     HELM3 = "HELM3",
+    HELMFILE = "HELMFILE",
     KUSTOMIZE = "KUSTOMIZE",
     KUSTOMIZE4 = "KUSTOMIZE4"
 }
 export declare const HELM_RENDERERS: Readonly<ManifestRenderers[]>;
+export declare const HELMFILE_RENDERER: Readonly<ManifestRenderers>;
 export declare const KUSTOMIZE_RENDERERS: Readonly<ManifestRenderers[]>;

package/dist/pipeline/config/stages/bakeManifest/helmfile/BakeHelmfileConfigForm.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { IFormikStageConfigInjectedProps } from '../../FormikStageConfig';
+export interface IBakeHelmfileConfigFormState {
+    gitRepoArtifactAccountNames: string[];
+}
+export declare class BakeHelmfileConfigForm extends React.Component<IFormikStageConfigInjectedProps, IBakeHelmfileConfigFormState> {
+    constructor(props: IFormikStageConfigInjectedProps);
+    private static readonly excludedArtifactTypes;
+    componentDidMount(): void;
+    private onTemplateArtifactEdited;
+    private onTemplateArtifactSelected;
+    private addInputArtifact;
+    private removeInputArtifact;
+    private getInputArtifact;
+    private outputNameChange;
+    private overrideChanged;
+    render(): JSX.Element;
+}

package/dist/pipeline/config/stages/bakeManifest/utils/getBakedArtifacts.d.ts

@@ -0,0 +1,4 @@
+import type { IArtifact, IExecutionContext } from '../../../../../domain';
+export declare const getBakedArtifacts: (context: IExecutionContext) => Array<IArtifact & {
+    reference: string;
+}>;

package/dist/pipeline/config/stages/bakeManifest/utils/getContentReference.d.ts

@@ -0,0 +1 @@
+export declare const getContentReference: (uri: string) => string;

package/dist/pipeline/config/triggers/artifacts/ArtifactService.d.ts

@@ -1,4 +1,7 @@
 export declare class ArtifactService {
     static getArtifactNames(type: string, accountName: string): PromiseLike<string[]>;
     static getArtifactVersions(type: string, accountName: string, artifactName: string): PromiseLike<string[]>;
+    static getArtifactByContentReference(contentRef: string): PromiseLike<{
+        reference: string;
+    }>;
 }

package/dist/pipeline/config/triggers/cdevents/CDEventsTrigger.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { FormikProps } from 'formik';
+import type { ICDEventsTrigger } from '../../../../domain';
+export interface ICDEventsTriggerProps {
+    formik: FormikProps<ICDEventsTrigger>;
+}
+export declare function CDEventsTrigger(cdeventsTriggerProps: ICDEventsTriggerProps): JSX.Element;

package/dist/pipeline/config/triggers/cdevents/cdevents.trigger.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/config/triggers/index.d.ts

@@ -1,4 +1,5 @@
 import './artifactory/artifactory.trigger';
+import './cdevents/cdevents.trigger';
 import './concourse/concourse.trigger';
 import './cron/cron.trigger';
 import './git/git.trigger';

package/dist/pipeline/index.d.ts

@@ -23,3 +23,5 @@ export * from './manualExecution/TriggerTemplate';
 export * from './service/ExecutionsTransformer';
 export * from './service/execution.service';
 export * from './status/ArtifactList';
+export * from './config/stages/bakeManifest/utils/getBakedArtifacts';
+export * from './config/stages/bakeManifest/utils/getContentReference';

package/dist/presentation/forms/inputs/NumberConcurrencyInput.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { IFormInputProps, OmitControlledInputPropsFrom } from './interface';
+interface INumberInputProps extends IFormInputProps, OmitControlledInputPropsFrom<React.InputHTMLAttributes<any>> {
+    inputClassName?: string;
+}
+export declare function NumberConcurrencyInput(props: INumberInputProps): JSX.Element;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/core",
   "license": "Apache-2.0",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -120,5 +120,5 @@
     "shx": "0.3.3",
     "typescript": "4.3.5"
   },
-  "gitHead": "eb226ee64d23c8c34be5ace816809a2262917e3f"
+  "gitHead": "8de1e3c576a24ce9a62290f86bc52772df4842d2"
 }

package/src/artifact/ArtifactIconService.ts

@@ -44,6 +44,7 @@ ArtifactIconService.registerType(ArtifactTypePatterns.CUSTOM_OBJECT, unknownArti
 ArtifactIconService.registerType(ArtifactTypePatterns.DOCKER_IMAGE, dockerIcon);
 ArtifactIconService.registerType(ArtifactTypePatterns.KUBERNETES, kubernetesIcon);
 ArtifactIconService.registerType(ArtifactTypePatterns.EMBEDDED_BASE64, embeddedBase64Icon);
+ArtifactIconService.registerType(ArtifactTypePatterns.REMOTE_BASE64, embeddedBase64Icon);
 ArtifactIconService.registerType(ArtifactTypePatterns.GCS_OBJECT, gcsObjectIcon);
 ArtifactIconService.registerType(ArtifactTypePatterns.GITHUB_FILE, gitHubFileIcon);
 ArtifactIconService.registerType(ArtifactTypePatterns.GIT_REPO, gitRepoIcon);

package/src/artifact/ArtifactTypes.ts

@@ -7,6 +7,7 @@ export const ArtifactTypePatterns: IArtifactTypePatterns = {
   CUSTOM_OBJECT: /custom\/object/,
   DOCKER_IMAGE: /docker\/image/,
   EMBEDDED_BASE64: /embedded\/base64/,
+  REMOTE_BASE64: /remote\/base64/,
   GCS_OBJECT: /gcs\/object/,
   GITHUB_FILE: /github\/file/,
   GIT_REPO: /git\/repo/,

package/src/config/settings.ts

@@ -34,6 +34,7 @@ export interface IFeatures {
   executionMarkerInformationModal?: boolean;
   fiatEnabled?: boolean;
   iapRefresherEnabled?: boolean;
+  lambdaAdditionalStages?: boolean;
   managedDelivery?: boolean;
   mdGitIntegration?: boolean;
   managedServiceAccounts?: boolean;

package/src/domain/IArtifact.ts

@@ -12,3 +12,6 @@ export interface IArtifact {
   kind?: string; // TODO delete
   customKind?: boolean; // TODO delete
 }
+
+export const ARTIFACT_TYPE_EMBEDDED = 'embedded/base64';
+export const ARTIFACT_TYPE_REMOTE = 'remote/base64';

package/src/domain/ITrigger.ts

@@ -91,6 +91,10 @@ export interface IWebhookTrigger extends ITrigger {
   payloadConstraints: { [key: string]: string };
 }
 
+export interface ICDEventsTrigger extends IWebhookTrigger {
+  attributeConstraints: { [key: string]: string };
+}
+
 export interface IWerckerTrigger extends IBuildTrigger {
   app: string;
   pipeline: string;

package/src/help/help.contents.ts

@@ -178,6 +178,11 @@ const helpContents: { [key: string]: string } = {
       <p>When provided, only a webhook with a payload containing at least the specified key/value pairs will be allowed to trigger this pipeline. For example, if you wanted to lock down the systems/users that can trigger this pipeline via this webhook, you could require the key "secret" and value "something-secret" as a constraint.</p>
       <p>The constraint values may be supplied as regex.</p>
   `,
+  'pipeline.config.trigger.cdevents.attributeConstraints': `
+      <p>CDEvents messages will have mandatory headers id, source, specversion, type accompanying the payload called <b>attributes</b>.</p>
+      <p>When provided, only a CDEvents message with attributes containing at least the specified key/value pairs will be allowed to trigger this pipeline.</p>
+      <p>The constraint value is a java regex string.</p>
+  `,
   'pipeline.config.trigger.pubsub.attributeConstraints': `
       <p>Pubsub messages can have system-specific metadata accompanying the payload called <b>attributes</b>.</p>
       <p>When provided, only a pubsub message with attributes containing at least the specified key/value pairs will be allowed to trigger this pipeline.</p>
@@ -307,6 +312,11 @@ const helpContents: { [key: string]: string } = {
   'pipeline.config.bake.manifest.kustomize.filePath': `
     <p>This is the relative path to the kustomization.yaml file within your Git repo.</p>
     <p>e.g.: <b>examples/wordpress/mysql/kustomization.yaml</b></p>`,
+  'pipeline.config.bake.manifest.helmfile.filePath': `
+    <p>This is the relative path to the directory containing the helmfile.yaml file within your Git repo.</p>
+    <p>e.g.: <b>chart/helmfile.yml</b></p>`,
+  'pipeline.config.bake.manifest.helmfile.name':
+    '<p> Name is used to set the expected artifact in the Produces Artifact section. </p>',
   'pipeline.config.bake.cf.manifest.name':
     '<p> Name should be the same as the expected artifact in the Produces Artifact section. </p>',
   'pipeline.config.bake.cf.manifest.templateArtifact': `

package/src/manifest/ManifestYaml.tsx

@@ -1,26 +1,48 @@
 import React from 'react';
 import { Modal } from 'react-bootstrap';
+import { ArtifactService } from '../pipeline/config/triggers/artifacts/ArtifactService';
+import { decodeUnicodeBase64 } from '../utils';
 
-export interface IManifestYamlProps {
+type IManifestYamlProps = {
   linkName: string;
-  manifestText: string;
   modalTitle: string;
-}
+} & ({ manifestText: string; manifestUri?: never } | { manifestText?: never; manifestUri: string });
 
-export function ManifestYaml(props: IManifestYamlProps) {
+export function ManifestYaml({ linkName, modalTitle, manifestText, manifestUri }: IManifestYamlProps) {
   const [modalVisible, setModalVisible] = React.useState<boolean>(false);
   const toggle = () => setModalVisible(!modalVisible);
+  const [fetchedManifestText, setFetchedManifestText] = React.useState<string>('Loading...');
+  const [error, setError] = React.useState<string | null>(null);
+
+  React.useEffect(() => {
+    if (manifestUri) {
+      ArtifactService.getArtifactByContentReference(manifestUri)
+        .then((manifest) => setFetchedManifestText(decodeUnicodeBase64(manifest.reference)))
+        .catch((e) => setError(`Error: ${typeof e !== 'string' ? e.data?.message ?? JSON.stringify(e) : e}`));
+    }
+  }, []);
+
   return (
     <>
       <a key="modal-link" onClick={toggle} className="clickable">
-        {props.linkName}
+        {linkName}
       </a>
       <Modal key="modal" show={modalVisible} onHide={toggle}>
         <Modal.Header closeButton={true}>
-          <h3>{props.modalTitle}</h3>
+          <h3>{modalTitle}</h3>
         </Modal.Header>
         <Modal.Body>
-          <textarea readOnly={true} rows={15} className="code" value={props.manifestText} />
+          {error ? (
+            <div className="alert alert-warning">
+              <p>{error}</p>
+            </div>
+          ) : null}
+          <textarea
+            readOnly={true}
+            rows={15}
+            className="code"
+            value={manifestUri ? fetchedManifestText : manifestText}
+          />
         </Modal.Body>
         <Modal.Footer>
           <button className="btn btn-primary" onClick={toggle}>

package/src/pipeline/config/stages/bakeManifest/BakeManifestConfig.tsx

@@ -4,7 +4,7 @@ import React from 'react';
 
 import { BakeManifestStageForm, validateProducedArtifacts } from './BakeManifestStageForm';
 import { FormikStageConfig } from '../FormikStageConfig';
-import { HELM_RENDERERS } from './ManifestRenderers';
+import { HELM_RENDERERS, HELMFILE_RENDERER } from './ManifestRenderers';
 import type { IStageConfigProps } from '../common';
 import type { IExpectedArtifact, IStage } from '../../../../domain';
 import { FormValidator } from '../../../../presentation';
@@ -46,6 +46,9 @@ export function validateBakeManifestStage(stage: IStage): FormikErrors<IStage> {
   if (HELM_RENDERERS.includes(stage.templateRenderer)) {
     formValidator.field('outputName', 'Name').required();
   }
+  if (HELMFILE_RENDERER === stage.templateRenderer) {
+    formValidator.field('outputName', 'Name').required();
+  }
 
   return formValidator.validateForm();
 }

package/src/pipeline/config/stages/bakeManifest/BakeManifestDetailsTab.tsx

@@ -3,10 +3,12 @@ import React from 'react';
 import type { IExecutionDetailsSectionProps } from '../common';
 import { ExecutionDetailsSection } from '../common';
 import { StageFailureMessage } from '../../../details';
-import type { IArtifact } from '../../../../domain';
+import { ARTIFACT_TYPE_EMBEDDED } from '../../../../domain';
 import { ManifestYaml } from '../../../../manifest';
 import { Overridable } from '../../../../overrideRegistry';
 import { decodeUnicodeBase64 } from '../../../../utils';
+import { getBakedArtifacts } from './utils/getBakedArtifacts';
+import { getContentReference } from './utils/getContentReference';
 
 @Overridable('bakeManifest.bakeManifestDetailsTab')
 export class BakeManifestDetailsTab extends React.Component<IExecutionDetailsSectionProps> {
@@ -14,20 +16,30 @@ export class BakeManifestDetailsTab extends React.Component<IExecutionDetailsSec
 
   public render() {
     const { current, name, stage } = this.props;
-    const bakedArtifacts: IArtifact[] = (stage.context.artifacts || []).filter(
-      (a: IArtifact) => a.type === 'embedded/base64',
-    );
+    const bakedArtifacts = getBakedArtifacts(stage.context);
+
     return (
       <ExecutionDetailsSection name={name} current={current}>
         <StageFailureMessage stage={stage} message={stage.failureMessage} />
-        {bakedArtifacts.map((artifact, i) => (
-          <ManifestYaml
-            key={i}
-            linkName={bakedArtifacts.length > 1 ? `Baked Manifest ${i} YAML` : 'Baked Manifest YAML'}
-            manifestText={decodeUnicodeBase64(artifact.reference)}
-            modalTitle="Baked Manifest"
-          />
-        ))}
+        {bakedArtifacts.map((artifact, i) => {
+          const linkName = bakedArtifacts.length > 1 ? `Baked Manifest ${i} YAML` : 'Baked Manifest YAML';
+
+          return artifact.type === ARTIFACT_TYPE_EMBEDDED ? (
+            <ManifestYaml
+              key={i}
+              linkName={linkName}
+              modalTitle="Baked Manifest"
+              manifestText={decodeUnicodeBase64(artifact.reference)}
+            />
+          ) : (
+            <ManifestYaml
+              key={i}
+              linkName={linkName}
+              modalTitle="Baked Manifest"
+              manifestUri={getContentReference(artifact.reference)}
+            />
+          );
+        })}
       </ExecutionDetailsSection>
     );
   }

package/src/pipeline/config/stages/bakeManifest/BakeManifestStageForm.tsx

@@ -2,11 +2,12 @@ import { isNil } from 'lodash';
 import React from 'react';
 
 import type { IFormikStageConfigInjectedProps } from '../FormikStageConfig';
-import { HELM_RENDERERS, KUSTOMIZE_RENDERERS } from './ManifestRenderers';
+import { HELM_RENDERERS, HELMFILE_RENDERER, KUSTOMIZE_RENDERERS } from './ManifestRenderers';
 import { ExpectedArtifactService } from '../../../../artifact';
 import { StageConfigField } from '../common';
 import type { IExpectedArtifact } from '../../../../domain';
 import { BakeHelmConfigForm } from './helm/BakeHelmConfigForm';
+import { BakeHelmfileConfigForm } from './helmfile/BakeHelmfileConfigForm';
 import { BakeKustomizeConfigForm } from './kustomize/BakeKustomizeConfigForm';
 import { ReactSelectInput } from '../../../../presentation';
 import { BASE_64_ARTIFACT_ACCOUNT, BASE_64_ARTIFACT_TYPE } from '../../triggers/artifacts/base64/Base64ArtifactEditor';
@@ -32,10 +33,13 @@ export function BakeManifestStageForm({ application, formik, pipeline }: IFormik
     if (HELM_RENDERERS.includes(stage.templateRenderer) && !isNil(stage.inputArtifact)) {
       formik.setFieldValue('inputArtifact', null);
     }
+    if (HELMFILE_RENDERER === stage.templateRenderer && !isNil(stage.inputArtifact)) {
+      formik.setFieldValue('inputArtifact', null);
+    }
   }, [stage.templateRenderer]);
 
   const templateRenderers = React.useMemo(() => {
-    return [...KUSTOMIZE_RENDERERS, ...HELM_RENDERERS];
+    return [...KUSTOMIZE_RENDERERS, ...HELM_RENDERERS, HELMFILE_RENDERER];
   }, []);
 
   return (
@@ -62,6 +66,9 @@ export function BakeManifestStageForm({ application, formik, pipeline }: IFormik
         {HELM_RENDERERS.includes(stage.templateRenderer) && (
           <BakeHelmConfigForm pipeline={pipeline} application={application} formik={formik} />
         )}
+        {HELMFILE_RENDERER === stage.templateRenderer && (
+          <BakeHelmfileConfigForm pipeline={pipeline} application={application} formik={formik} />
+        )}
       </div>
     </div>
   );

package/src/pipeline/config/stages/bakeManifest/ManifestRenderers.ts

@@ -1,11 +1,13 @@
 export enum ManifestRenderers {
   HELM2 = 'HELM2',
   HELM3 = 'HELM3',
+  HELMFILE = 'HELMFILE',
   KUSTOMIZE = 'KUSTOMIZE',
   KUSTOMIZE4 = 'KUSTOMIZE4',
 }
 
 export const HELM_RENDERERS: Readonly<ManifestRenderers[]> = [ManifestRenderers.HELM2, ManifestRenderers.HELM3];
+export const HELMFILE_RENDERER: Readonly<ManifestRenderers> = ManifestRenderers.HELMFILE;
 export const KUSTOMIZE_RENDERERS: Readonly<ManifestRenderers[]> = [
   ManifestRenderers.KUSTOMIZE,
   ManifestRenderers.KUSTOMIZE4,

package/src/pipeline/config/stages/bakeManifest/helmfile/BakeHelmfileConfigForm.spec.tsx

@@ -0,0 +1,132 @@
+import { mock } from 'angular';
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { StageConfigField } from '../../../..';
+import { BakeHelmfileConfigForm } from './BakeHelmfileConfigForm';
+import { AccountService } from '../../../../../account';
+import { ApplicationModelBuilder } from '../../../../../application';
+import { ExpectedArtifactService } from '../../../../../artifact';
+import type { IExpectedArtifact, IStage } from '../../../../../domain';
+import { SpinFormik } from '../../../../../presentation';
+import { REACT_MODULE } from '../../../../../reactShims';
+
+describe('<BakeHelmfileConfigForm />', () => {
+  beforeEach(mock.module(REACT_MODULE));
+  beforeEach(mock.inject());
+
+  const helmfileFilePathFieldName = 'Helmfile File Path';
+
+  const getProps = () => {
+    return {
+      application: ApplicationModelBuilder.createApplicationForTests('my-application'),
+      pipeline: {
+        application: 'my-application',
+        id: 'pipeline-id',
+        limitConcurrent: true,
+        keepWaitingPipelines: true,
+        name: 'My Pipeline',
+        parameterConfig: [],
+        stages: [],
+        triggers: [],
+      },
+    } as any;
+  };
+
+  beforeEach(() =>
+    spyOn(AccountService, 'getArtifactAccounts').and.returnValue(
+      Promise.resolve([
+        { name: 'gitrepo', types: ['something-else', 'git/repo'] },
+        { name: 'notgitrepo', types: ['something-else'] },
+      ]),
+    ),
+  );
+
+  it('renders the helmfile file path element when the template artifact is from an account that handles git/repo artifacts', async () => {
+    const stage = ({
+      inputArtifacts: [{ account: 'gitrepo' }],
+    } as unknown) as IStage;
+
+    const props = getProps();
+
+    const component = mount(
+      <SpinFormik
+        initialValues={stage}
+        onSubmit={() => null}
+        validate={() => null}
+        render={(formik) => <BakeHelmfileConfigForm {...props} formik={formik} />}
+      />,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve)); // wait one js tick for promise to resolve
+    component.setProps({}); // force a re-render
+
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === helmfileFilePathFieldName).length).toBe(1);
+  });
+
+  it('does not render the helmfile file path element when the template artifact is from an account that does not handle git/repo artifacts', async () => {
+    const stage = ({
+      inputArtifacts: [{ account: 'notgitrepo' }],
+    } as unknown) as IStage;
+
+    const props = getProps();
+
+    const component = mount(
+      <SpinFormik
+        initialValues={stage}
+        onSubmit={() => null}
+        validate={() => null}
+        render={(formik) => <BakeHelmfileConfigForm {...props} formik={formik} />}
+      />,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve)); // wait one js tick for promise to resolve
+    component.setProps({}); // force a re-render
+
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === helmfileFilePathFieldName).length).toBe(0);
+  });
+
+  it('render the helmfile file path if the id of the git artifact is given but the account value does not exist', async () => {
+    const expectedArtifactDisplayName = 'test-artifact';
+    const expectedArtifactId = 'test-artifact-id';
+    const expectedGitArtifact: IExpectedArtifact = {
+      defaultArtifact: {
+        customKind: true,
+        id: 'defaultArtifact-id',
+      },
+      displayName: expectedArtifactDisplayName,
+      id: expectedArtifactId,
+      matchArtifact: {
+        artifactAccount: 'gitrepo',
+        id: expectedArtifactId,
+        reference: 'git repo',
+        type: 'git/repo',
+        version: 'master',
+      },
+      useDefaultArtifact: false,
+      usePriorArtifact: false,
+    };
+    const stage = ({
+      inputArtifacts: [{ id: expectedArtifactId }],
+    } as unknown) as IStage;
+
+    spyOn(ExpectedArtifactService, 'getExpectedArtifactsAvailableToStage').and.returnValue([expectedGitArtifact]);
+
+    const props = getProps();
+
+    const component = mount(
+      <SpinFormik
+        initialValues={stage}
+        onSubmit={() => null}
+        validate={() => null}
+        render={(formik) => <BakeHelmfileConfigForm {...props} formik={formik} />}
+      />,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve)); // wait one js tick for promise to resolve
+    component.setProps({}); // force a re-render
+
+    expect(component.find('.Select-value-label > span').text().includes(expectedArtifactDisplayName)).toBe(true);
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === helmfileFilePathFieldName).length).toBe(1);
+  });
+});