@spinnaker/core 0.24.1 → 0.26.0

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);
+  });
+});

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

@@ -0,0 +1,271 @@
+import React from 'react';
+
+import type { IFormikStageConfigInjectedProps } from '../../FormikStageConfig';
+import { AccountService } from '../../../../../account';
+import {
+  ArtifactTypePatterns,
+  excludeAllTypesExcept,
+  ExpectedArtifactService,
+  StageArtifactSelectorDelegate,
+} from '../../../../../artifact';
+import { StageConfigField } from '../../common/stageConfigField/StageConfigField';
+import type { IArtifact, IExpectedArtifact } from '../../../../../domain';
+import { MapEditor } from '../../../../../forms';
+import { CheckboxInput, TextInput } from '../../../../../presentation';
+
+export interface IBakeHelmfileConfigFormState {
+  gitRepoArtifactAccountNames: string[];
+}
+
+export class BakeHelmfileConfigForm extends React.Component<
+  IFormikStageConfigInjectedProps,
+  IBakeHelmfileConfigFormState
+> {
+  constructor(props: IFormikStageConfigInjectedProps) {
+    super(props);
+    this.state = { gitRepoArtifactAccountNames: [] };
+  }
+
+  private static readonly excludedArtifactTypes = excludeAllTypesExcept(
+    ArtifactTypePatterns.BITBUCKET_FILE,
+    ArtifactTypePatterns.CUSTOM_OBJECT,
+    ArtifactTypePatterns.EMBEDDED_BASE64,
+    ArtifactTypePatterns.GCS_OBJECT,
+    ArtifactTypePatterns.GIT_REPO,
+    ArtifactTypePatterns.GITHUB_FILE,
+    ArtifactTypePatterns.GITLAB_FILE,
+    ArtifactTypePatterns.S3_OBJECT,
+    ArtifactTypePatterns.HELM_CHART,
+    ArtifactTypePatterns.HTTP_FILE,
+    ArtifactTypePatterns.ORACLE_OBJECT,
+  );
+
+  public componentDidMount() {
+    const stage = this.props.formik.values;
+    if (stage.inputArtifacts && stage.inputArtifacts.length === 0) {
+      this.props.formik.setFieldValue('inputArtifacts', [
+        {
+          account: '',
+          id: '',
+        },
+      ]);
+    }
+
+    // If the Expected Artifact id is provided but the account is not, then attempt to find the artifact from
+    // upstream stages and set the account value.
+    // This is needed because helmfile file path field will need to be rendered if the artifact has a git repo account type
+    const expectedArtifact = this.getInputArtifact(stage, 0);
+    if (expectedArtifact.id && !expectedArtifact.account) {
+      const availableArtifacts = ExpectedArtifactService.getExpectedArtifactsAvailableToStage(
+        stage,
+        this.props.pipeline,
+      );
+      const expectedMatchedArtifact = availableArtifacts.find((a) => a.id === expectedArtifact.id);
+      if (expectedMatchedArtifact && expectedMatchedArtifact.matchArtifact) {
+        this.props.formik.setFieldValue(
+          `inputArtifacts[0].account`,
+          expectedMatchedArtifact.matchArtifact.artifactAccount,
+        );
+      }
+    }
+
+    AccountService.getArtifactAccounts().then((artifactAccounts) => {
+      this.setState({
+        gitRepoArtifactAccountNames: artifactAccounts
+          .filter((account) => account.types.some((type) => ArtifactTypePatterns.GIT_REPO.test(type)))
+          .map((account) => account.name),
+      });
+    });
+  }
+
+  private onTemplateArtifactEdited = (artifact: IArtifact, index: number) => {
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].id`, null);
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].artifact`, artifact);
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].account`, artifact.artifactAccount);
+  };
+
+  private onTemplateArtifactSelected = (artifact: IExpectedArtifact, index: number) => {
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].id`, artifact.id);
+    this.props.formik.setFieldValue(`inputArtifacts[${index}].artifact`, null);
+    // Set the account to matchArtifact.artifactAccount if it exists.
+    // This account value will be used to determine if the Helm Chart File Path should be displayed.
+    if (artifact.matchArtifact) {
+      this.props.formik.setFieldValue(`inputArtifacts[${index}].account`, artifact.matchArtifact.artifactAccount);
+    } else {
+      this.props.formik.setFieldValue(`inputArtifacts[${index}].account`, null);
+    }
+  };
+
+  private addInputArtifact = () => {
+    const stage = this.props.formik.values;
+    const newInputArtifacts = [
+      ...stage.inputArtifacts,
+      {
+        account: '',
+        id: '',
+      },
+    ];
+
+    this.props.formik.setFieldValue('inputArtifacts', newInputArtifacts);
+  };
+
+  private removeInputArtifact = (index: number) => {
+    const stage = this.props.formik.values;
+    const newInputArtifacts = [...stage.inputArtifacts];
+    newInputArtifacts.splice(index, 1);
+    this.props.formik.setFieldValue('inputArtifacts', newInputArtifacts);
+  };
+
+  private getInputArtifact = (stage: any, index: number) => {
+    if (!stage.inputArtifacts || stage.inputArtifacts.length === 0) {
+      return {
+        account: '',
+        id: '',
+      };
+    } else {
+      return stage.inputArtifacts[index];
+    }
+  };
+
+  private outputNameChange = (outputName: string) => {
+    const stage = this.props.formik.values;
+    const expectedArtifacts = stage.expectedArtifacts;
+    if (
+      expectedArtifacts &&
+      expectedArtifacts.length === 1 &&
+      expectedArtifacts[0].matchArtifact &&
+      expectedArtifacts[0].matchArtifact.type === 'embedded/base64'
+    ) {
+      this.props.formik.setFieldValue('expectedArtifacts', [
+        {
+          ...expectedArtifacts[0],
+          matchArtifact: {
+            ...expectedArtifacts[0].matchArtifact,
+            name: outputName,
+          },
+        },
+      ]);
+    }
+  };
+
+  private overrideChanged = (overrides: any) => {
+    this.props.formik.setFieldValue('overrides', overrides);
+  };
+
+  public render() {
+    const stage = this.props.formik.values;
+    return (
+      <>
+        <h4>Helmfile Options</h4>
+        <StageConfigField fieldColumns={3} label={'Name'} helpKey="pipeline.config.bake.manifest.helmfile.name">
+          <TextInput
+            onChange={(e: React.ChangeEvent<any>) => {
+              this.props.formik.setFieldValue('outputName', e.target.value);
+              this.outputNameChange(e.target.value);
+            }}
+            value={stage.outputName}
+          />
+        </StageConfigField>
+        <h4>Template Artifact</h4>
+        <StageArtifactSelectorDelegate
+          artifact={this.getInputArtifact(stage, 0).artifact}
+          excludedArtifactTypePatterns={BakeHelmfileConfigForm.excludedArtifactTypes}
+          expectedArtifactId={this.getInputArtifact(stage, 0).id}
+          helpKey="pipeline.config.bake.manifest.expectedArtifact"
+          label="Expected Artifact"
+          onArtifactEdited={(artifact) => {
+            this.onTemplateArtifactEdited(artifact, 0);
+          }}
+          onExpectedArtifactSelected={(artifact: IExpectedArtifact) => this.onTemplateArtifactSelected(artifact, 0)}
+          pipeline={this.props.pipeline}
+          stage={stage}
+        />
+        {this.state.gitRepoArtifactAccountNames.includes(this.getInputArtifact(stage, 0).account) && (
+          <StageConfigField label="Helmfile File Path" helpKey="pipeline.config.bake.manifest.helmfile.filePath">
+            <TextInput
+              onChange={(e: React.ChangeEvent<any>) => {
+                this.props.formik.setFieldValue('helmfileFilePath', e.target.value);
+              }}
+              value={stage.helmfileFilePath}
+            />
+          </StageConfigField>
+        )}
+        <h4>Overrides</h4>
+        {stage.inputArtifacts && stage.inputArtifacts.length > 1 && (
+          <div className="row form-group">
+            {stage.inputArtifacts.slice(1).map((a: any, index: number) => {
+              return (
+                <div key={index}>
+                  <div className="col-md-offset-1 col-md-9">
+                    <StageArtifactSelectorDelegate
+                      artifact={a.artifact}
+                      excludedArtifactTypePatterns={[]}
+                      expectedArtifactId={a.id}
+                      label="Expected Artifact"
+                      onArtifactEdited={(artifact) => {
+                        this.onTemplateArtifactEdited(artifact, index + 1);
+                      }}
+                      onExpectedArtifactSelected={(artifact: IExpectedArtifact) =>
+                        this.onTemplateArtifactSelected(artifact, index + 1)
+                      }
+                      pipeline={this.props.pipeline}
+                      stage={stage}
+                    />
+                  </div>
+                  <div className="col-md-1">
+                    <div className="form-control-static">
+                      <button onClick={() => this.removeInputArtifact(index + 1)}>
+                        <span className="glyphicon glyphicon-trash" />
+                        <span className="sr-only">Remove field</span>
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+        )}
+        <StageConfigField fieldColumns={8} label={''}>
+          <button className="btn btn-block btn-sm add-new" onClick={() => this.addInputArtifact()}>
+            <span className="glyphicon glyphicon-plus-sign" />
+            Add value artifact
+          </button>
+        </StageConfigField>
+        <StageConfigField fieldColumns={6} label="Overrides">
+          {stage.overrides && (
+            <MapEditor
+              addButtonLabel={'Add override'}
+              model={stage.overrides}
+              allowEmpty={true}
+              onChange={(o: any) => this.overrideChanged(o)}
+            />
+          )}
+        </StageConfigField>
+        <StageConfigField
+          fieldColumns={6}
+          helpKey={'pipeline.config.bake.manifest.helm.includeCRDs'}
+          label="Include CRDs"
+        >
+          <CheckboxInput
+            value={stage.includeCRDs}
+            text={''}
+            onChange={() => this.props.formik.setFieldValue('includeCRDs', !stage.includeCRDs)}
+          />
+        </StageConfigField>
+        <StageConfigField
+          fieldColumns={6}
+          helpKey={'pipeline.config.bake.manifest.overrideExpressionEvaluation'}
+          label="Expression Evaluation"
+        >
+          <CheckboxInput
+            value={stage.evaluateOverrideExpressions}
+            text={'Evaluate SpEL expressions in overrides at bake time'}
+            onChange={() =>
+              this.props.formik.setFieldValue('evaluateOverrideExpressions', !stage.evaluateOverrideExpressions)
+            }
+          />
+        </StageConfigField>
+      </>
+    );
+  }
+}

package/src/pipeline/config/stages/bakeManifest/utils/getBakedArtifacts.ts

@@ -0,0 +1,13 @@
+import type { IArtifact, IExecutionContext } from '../../../../../domain';
+import { ARTIFACT_TYPE_EMBEDDED, ARTIFACT_TYPE_REMOTE } from '../../../../../domain';
+
+// IArtifact type is wrong and does not represent the real value
+export const getBakedArtifacts = (context: IExecutionContext): Array<IArtifact & { reference: string }> => {
+  if ('artifacts' in context) {
+    return context.artifacts.filter(
+      (a: IArtifact) => (a.type === ARTIFACT_TYPE_EMBEDDED || a.type === ARTIFACT_TYPE_REMOTE) && a.reference,
+    );
+  } else {
+    return [];
+  }
+};

package/src/pipeline/config/stages/bakeManifest/utils/getContentReference.ts

@@ -0,0 +1,3 @@
+export const getContentReference = (uri: string): string => {
+  return uri.replace(/^ref?:\/\//, '');
+};

package/src/pipeline/config/triggers/artifacts/ArtifactService.ts

@@ -11,4 +11,8 @@ export class ArtifactService {
       .query({ type: type, artifactName: artifactName })
       .get();
   }
+
+  public static getArtifactByContentReference(contentRef: string): PromiseLike<{ reference: string }> {
+    return REST(`/artifacts/content-address/${contentRef}`).get();
+  }
 }

package/src/pipeline/config/triggers/cdevents/CDEventsTrigger.tsx

@@ -0,0 +1,48 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+
+import { SETTINGS } from '../../../../config/settings';
+import type { ICDEventsTrigger } from '../../../../domain';
+import { MapEditorInput } from '../../../../forms';
+import { HelpField } from '../../../../help';
+import { FormikFormField, TextInput } from '../../../../presentation';
+
+export interface ICDEventsTriggerProps {
+  formik: FormikProps<ICDEventsTrigger>;
+}
+
+export function CDEventsTrigger(cdeventsTriggerProps: ICDEventsTriggerProps) {
+  const { formik } = cdeventsTriggerProps;
+  const trigger = formik.values;
+  const { source, type } = trigger;
+
+  return (
+    <>
+      <FormikFormField
+        name="source"
+        label="Source"
+        help={<HelpField id="pipeline.config.trigger.webhook.source" />}
+        input={(props) => (
+          <div className="flex-container-v">
+            <TextInput {...props} />
+            <i>{`${SETTINGS.gateUrl}/webhooks/${type}/${source || '<source>'}`}</i>
+          </div>
+        )}
+      />
+
+      <FormikFormField
+        name="payloadConstraints"
+        label="Payload Constraints"
+        help={<HelpField id="pipeline.config.trigger.webhook.payloadConstraints" />}
+        input={(props) => <MapEditorInput {...props} addButtonLabel="Add payload constraint" />}
+      />
+
+      <FormikFormField
+        name="attributeConstraints"
+        label="Attribute Constraints "
+        help={<HelpField id="pipeline.config.trigger.cdevents.attributeConstraints" />}
+        input={(props) => <MapEditorInput {...props} addButtonLabel="Add attribute constraint" />}
+      />
+    </>
+  );
+}

package/src/pipeline/config/triggers/cdevents/cdevents.trigger.ts

@@ -0,0 +1,19 @@
+import { CDEventsTrigger } from './CDEventsTrigger';
+import { ArtifactTypePatterns } from '../../../../artifact';
+import { Registry } from '../../../../registry';
+
+Registry.pipeline.registerTrigger({
+  component: CDEventsTrigger,
+  description: 'Executes the pipeline when a CDEvents webhook is received.',
+  excludedArtifactTypePatterns: [ArtifactTypePatterns.JENKINS_FILE],
+  key: 'cdevents',
+  label: 'CDEvents',
+  validators: [
+    {
+      type: 'serviceAccountAccess',
+      message: `You do not have access to the service account configured in this pipeline's CDEvents trigger.
+                You will not be able to save your edits to this pipeline.`,
+      preventSave: true,
+    },
+  ],
+});

package/src/pipeline/config/triggers/index.ts

@@ -1,6 +1,7 @@
 'use strict';
 
 import './artifactory/artifactory.trigger';
+import './cdevents/cdevents.trigger';
 import './concourse/concourse.trigger';
 import './cron/cron.trigger';
 import './git/git.trigger';

package/src/pipeline/create/CreatePipelineModal.tsx

@@ -129,7 +129,7 @@ export class CreatePipelineModal extends React.Component<ICreatePipelineModalPro
       ? this.getDefaultConfig()
       : command.config;
 
-    pipelineConfig.name = command.name;
+    pipelineConfig.name = command.name.trim();
     pipelineConfig.index = this.props.application.getDataSource('pipelineConfigs').data.length;
     delete pipelineConfig.id;