@spinnaker/core 0.24.1 → 0.25.0

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;
 

package/src/pipeline/index.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/src/presentation/forms/inputs/NumberConcurrencyInput.tsx

@@ -0,0 +1,29 @@
+import React from 'react';
+
+import { useInternalValidator } from './hooks';
+import type { IFormInputProps, OmitControlledInputPropsFrom } from './interface';
+import { orEmptyString, validationClassName } from './utils';
+import type { IValidator } from '../validation';
+import { composeValidators, Validators } from '../validation';
+
+interface INumberInputProps extends IFormInputProps, OmitControlledInputPropsFrom<React.InputHTMLAttributes<any>> {
+  inputClassName?: string;
+}
+
+const isNumber = (val: any): val is number => typeof val === 'number';
+
+export function NumberConcurrencyInput(props: INumberInputProps) {
+  const { value, validation, inputClassName, ...otherProps } = props;
+
+  const minMaxValidator: IValidator = (val: any, label?: string) => {
+    const minValidator = isNumber(props.min) ? Validators.minValue(props.min) : undefined;
+    const maxValidator = isNumber(props.max) ? Validators.maxValue(props.max) : undefined;
+    const validator = composeValidators([minValidator, maxValidator]);
+    return validator ? validator(val, label) : null;
+  };
+
+  useInternalValidator(validation, minMaxValidator);
+
+  const className = `NumberInput form-control ${orEmptyString(inputClassName)} ${validationClassName(validation)}`;
+  return <input className={className} type="number" value={orEmptyString(value)} {...otherProps} />;
+}