@spinnaker/cloudrun 0.1.6

package/src/manifest/manifest.service.ts

@@ -0,0 +1,89 @@
+import type { Application, IManifest } from '@spinnaker/core';
+import { ManifestReader } from '@spinnaker/core';
+
+export interface IStageManifest {
+  kind: string;
+  apiVersion: string;
+  metadata: {
+    namespace: string;
+    name: string;
+  };
+}
+
+export interface IManifestParams {
+  account: string;
+  location: string;
+  name: string;
+}
+
+export type IManifestCallback = (manifest: IManifest) => void;
+
+export class CloudrunManifestService {
+  public static subscribe(app: Application, params: IManifestParams, fn: IManifestCallback): () => void {
+    CloudrunManifestService.updateManifest(params, fn);
+    return app.onRefresh(null, () => CloudrunManifestService.updateManifest(params, fn));
+  }
+
+  private static updateManifest(params: IManifestParams, fn: IManifestCallback) {
+    ManifestReader.getManifest(params.account, params.location, params.name).then((manifest) => fn(manifest));
+  }
+
+  public static manifestIdentifier(manifest: IStageManifest) {
+    const kind = manifest.kind.toLowerCase();
+    // manifest.metadata.namespace doesn't exist if it's a namespace being deployed
+    const namespace = (manifest.metadata.namespace || '_').toLowerCase();
+    const name = manifest.metadata.name.toLowerCase();
+    const apiVersion = (manifest.apiVersion || '_').toLowerCase();
+    // assuming this identifier is opaque and not parsed anywhere. Including the
+    // apiVersion will prevent collisions with CRD kinds without having any visible
+    // effect elsewhere
+    return `${namespace} ${kind} ${apiVersion} ${name}`;
+  }
+
+  public static stageManifestToManifestParams(manifest: IStageManifest, account: string): IManifestParams {
+    return {
+      account,
+      name: CloudrunManifestService.scopedKind(manifest) + ' ' + manifest.metadata.name,
+      location: manifest.metadata.namespace == null ? '_' : manifest.metadata.namespace,
+    };
+  }
+
+  private static apiGroup(manifest: IStageManifest): string {
+    const parts = (manifest.apiVersion || '_').split('/');
+    if (parts.length < 2) {
+      return '';
+    }
+    return parts[0];
+  }
+
+  private static isCRDGroup(manifest: IStageManifest): boolean {
+    return !CloudrunManifestService.BUILT_IN_GROUPS.includes(CloudrunManifestService.apiGroup(manifest));
+  }
+
+  private static scopedKind(manifest: IStageManifest): string {
+    if (CloudrunManifestService.isCRDGroup(manifest)) {
+      return manifest.kind + '.' + CloudrunManifestService.apiGroup(manifest);
+    }
+
+    return manifest.kind;
+  }
+
+  private static readonly BUILT_IN_GROUPS = [
+    '',
+    'core',
+    'batch',
+    'apps',
+    'extensions',
+    'storage.k8s.io',
+    'apiextensions.k8s.io',
+    'apiregistration.k8s.io',
+    'policy',
+    'scheduling.k8s.io',
+    'settings.k8s.io',
+    'authorization.k8s.io',
+    'authentication.k8s.io',
+    'rbac.authorization.k8s.io',
+    'certifcates.k8s.io',
+    'networking.k8s.io',
+  ];
+}

package/src/manifest/manifestCommandBuilder.service.ts

@@ -0,0 +1,116 @@
+import { cloneDeep } from 'lodash';
+import { $q } from 'ngimport';
+
+import type { Application, IAccountDetails, IArtifactAccount, IMoniker } from '@spinnaker/core';
+import { AccountService } from '@spinnaker/core';
+
+import { ManifestSource } from './ManifestSource';
+
+export interface ICloudrunManifestCommandData {
+  command: ICloudrunManifestCommand;
+  metadata: ICloudrunManifestCommandMetadata;
+}
+
+export interface ICloudrunManifestCommand {
+  account: string;
+  cloudProvider: string;
+  manifest: any;
+  manifests: any[];
+  relationships: ICloudrunManifestSpinnakerRelationships;
+  moniker: IMoniker;
+  manifestArtifactId?: string;
+  manifestArtifactAccount?: string;
+  source: ManifestSource;
+  versioned?: boolean;
+}
+
+export interface ICloudrunManifestCommandMetadata {
+  backingData: any;
+}
+
+export interface ICloudrunManifestSpinnakerRelationships {
+  loadBalancers?: string[];
+  securityGroups?: string[];
+}
+
+export class CloudrunManifestCommandBuilder {
+  public static manifestCommandIsValid(command: ICloudrunManifestCommand): boolean {
+    if (!command.moniker) {
+      return false;
+    }
+
+    if (!command.moniker.app) {
+      return false;
+    }
+
+    return true;
+  }
+
+  public static copyAndCleanCommand(input: ICloudrunManifestCommand): ICloudrunManifestCommand {
+    const command = cloneDeep(input);
+    return command;
+  }
+
+  public static buildNewManifestCommand(
+    app: Application,
+    sourceManifest?: any,
+    sourceMoniker?: IMoniker,
+    sourceAccount?: string,
+  ): PromiseLike<ICloudrunManifestCommandData> {
+    const dataToFetch = {
+      accounts: AccountService.getAllAccountDetailsForProvider('cloudrun'),
+      artifactAccounts: AccountService.getArtifactAccounts(),
+    };
+
+    return $q
+      .all(dataToFetch)
+      .then((backingData: { accounts: IAccountDetails[]; artifactAccounts: IArtifactAccount[] }) => {
+        const { accounts, artifactAccounts } = backingData;
+
+        const account = accounts.some((a) => a.name === sourceAccount)
+          ? accounts.find((a) => a.name === sourceAccount).name
+          : accounts.length
+          ? accounts[0].name
+          : null;
+
+        let manifestArtifactAccount: string = null;
+        const [artifactAccountData] = artifactAccounts;
+        if (artifactAccountData) {
+          manifestArtifactAccount = artifactAccountData.name;
+        }
+
+        const cloudProvider = 'cloudrun';
+        const moniker = sourceMoniker || {
+          app: app.name,
+        };
+
+        const relationships = {
+          loadBalancers: [] as string[],
+          securityGroups: [] as string[],
+        };
+
+        const versioned: any = null;
+
+        return {
+          command: {
+            cloudProvider,
+            manifest: null,
+            manifests: Array.isArray(sourceManifest)
+              ? sourceManifest
+              : sourceManifest != null
+              ? [sourceManifest]
+              : null,
+            relationships,
+            moniker,
+            account,
+            versioned,
+            manifestArtifactAccount,
+            source: ManifestSource.TEXT,
+          },
+          metadata: {
+            backingData,
+          },
+        } as ICloudrunManifestCommandData;
+      });
+  }
+}

package/src/manifest/wizard/BasicSettings.tsx

@@ -0,0 +1,57 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+
+import type { IAccount } from '@spinnaker/core';
+import { AccountSelectInput, HelpField } from '@spinnaker/core';
+
+import type { ICloudrunManifestCommandData } from '../manifestCommandBuilder.service';
+
+export interface IManifestBasicSettingsProps {
+  accounts: IAccount[];
+  onAccountSelect: (account: string) => void;
+  selectedAccount: string;
+}
+
+export function ManifestBasicSettings({ accounts, onAccountSelect, selectedAccount }: IManifestBasicSettingsProps) {
+  return (
+    <div className="form-horizontal">
+      <div className="form-group">
+        <div className="col-md-3 sm-label-right">
+          Account <HelpField id="cloudrun.manifest.account" />
+        </div>
+        <div className="col-md-8">
+          <AccountSelectInput
+            value={selectedAccount}
+            onChange={(evt: any) => onAccountSelect(evt.target.value)}
+            readOnly={false}
+            accounts={accounts}
+            provider="cloudrun"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export interface IWizardManifestBasicSettingsProps {
+  formik: FormikProps<ICloudrunManifestCommandData>;
+}
+
+export class WizardManifestBasicSettings extends React.Component<IWizardManifestBasicSettingsProps> {
+  private accountUpdated = (account: string): void => {
+    const { formik } = this.props;
+    formik.values.command.account = account;
+    formik.setFieldValue('account', account);
+  };
+
+  public render() {
+    const { formik } = this.props;
+    return (
+      <ManifestBasicSettings
+        accounts={formik.values.metadata.backingData.accounts}
+        onAccountSelect={this.accountUpdated}
+        selectedAccount={formik.values.command.account}
+      />
+    );
+  }
+}

package/src/pipeline/pipeline.module.ts

@@ -0,0 +1,6 @@
+import { module } from 'angular';
+
+import { CLOUDRUN_EDIT_LOAD_BALANCER_STAGE } from './stages/editLoadBalancer/cloudrunEditLoadBalancerStage';
+
+export const CLOUDRUN_PIPELINE_MODULE = 'spinnaker.cloudrun.pipeline.module';
+module(CLOUDRUN_PIPELINE_MODULE, [CLOUDRUN_EDIT_LOAD_BALANCER_STAGE]);

package/src/pipeline/stages/deployManifest/DeployStageConfig.tsx

@@ -0,0 +1,73 @@
+import { cloneDeep } from 'lodash';
+import React from 'react';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { IAccountDetails, IStage, IStageConfigProps } from '@spinnaker/core';
+import { AccountService, FormikStageConfig } from '@spinnaker/core';
+
+import { DeployStageForm } from './DeployStageForm';
+import { ManifestSource } from '../../../manifest/ManifestSource';
+
+interface IDeployManifestStageConfigState {
+  accounts: IAccountDetails[];
+}
+
+export class DeployStageConfig extends React.Component<IStageConfigProps, IDeployManifestStageConfigState> {
+  private stage: IStage;
+  private destroy$ = new Subject();
+
+  public constructor(props: IStageConfigProps) {
+    super(props);
+    this.state = {
+      accounts: [],
+    };
+    const { stage: initialStageConfig } = props;
+    const stage = cloneDeep(initialStageConfig);
+    if (!stage.source) {
+      stage.source = ManifestSource.TEXT;
+    }
+    if (!stage.skipExpressionEvaluation) {
+      stage.skipExpressionEvaluation = false;
+    }
+    if (!stage.cloudProvider) {
+      stage.cloudProvider = 'cloudrun';
+    }
+    if (!stage.moniker) {
+      stage.moniker = {};
+    }
+    if (!stage.moniker.app) {
+      stage.moniker.app = props.application.name;
+    }
+    // Intentionally initializing the stage config only once in the constructor
+    // The stage config is then completely owned within FormikStageConfig's Formik state
+    this.stage = stage;
+  }
+
+  public componentDidMount() {
+    this.fetchAccounts();
+  }
+
+  private fetchAccounts = (): void => {
+    observableFrom(AccountService.getAllAccountDetailsForProvider('cloudrun'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((accounts: IAccountDetails[]) => {
+        this.setState({ accounts });
+      });
+  };
+
+  public componentWillUnmount() {
+    this.destroy$.next();
+  }
+
+  public render() {
+    return (
+      <FormikStageConfig
+        {...this.props}
+        stage={this.stage}
+        onChange={this.props.updateStage}
+        render={(props) => <DeployStageForm {...props} accounts={this.state.accounts} />}
+      />
+    );
+  }
+}

package/src/pipeline/stages/deployManifest/DeployStageForm.tsx

@@ -0,0 +1,185 @@
+import { capitalize, get, isEmpty, map } from 'lodash';
+import React from 'react';
+import type { Option } from 'react-select';
+
+import type { IAccountDetails, IArtifact, IExpectedArtifact, IFormikStageConfigInjectedProps } from '@spinnaker/core';
+import {
+  ArtifactTypePatterns,
+  CheckboxInput,
+  RadioButtonInput,
+  StageArtifactSelectorDelegate,
+  StageConfigField,
+  yamlDocumentsToString,
+  YamlEditor,
+} from '@spinnaker/core';
+
+import type { IManifestBindArtifact } from './ManifestBindArtifactsSelector';
+import { ManifestBindArtifactsSelector } from './ManifestBindArtifactsSelector';
+import { ManifestSource } from '../../../manifest/ManifestSource';
+import { ManifestBasicSettings } from '../../../manifest/wizard/BasicSettings';
+import { ServerGroupNamePreview } from './serverGroupNamePreview';
+
+interface IDeployManifestStageConfigFormProps {
+  accounts: IAccountDetails[];
+}
+
+interface IDeployManifestStageConfigFormState {
+  rawManifest: string;
+  application: string;
+  stack: string;
+  details: string;
+}
+
+export class DeployStageForm extends React.Component<
+  IDeployManifestStageConfigFormProps & IFormikStageConfigInjectedProps,
+  IDeployManifestStageConfigFormState
+> {
+  private readonly excludedManifestArtifactTypes = [
+    ArtifactTypePatterns.FRONT50_PIPELINE_TEMPLATE,
+    ArtifactTypePatterns.MAVEN_FILE,
+  ];
+
+  public constructor(props: IDeployManifestStageConfigFormProps & IFormikStageConfigInjectedProps) {
+    super(props);
+    const stage = this.props.formik.values;
+    const manifests: any[] = get(props.formik.values, 'manifests');
+    const isTextManifest: boolean = get(props.formik.values, 'source') === ManifestSource.TEXT;
+    this.state = {
+      rawManifest: !isEmpty(manifests) && isTextManifest ? yamlDocumentsToString(manifests) : '',
+      application: this.props.application.name,
+      stack: get(stage, 'stack'),
+      details: get(stage, 'details'),
+    };
+  }
+
+  private getSourceOptions = (): Array<Option<string>> => {
+    return map([ManifestSource.TEXT, ManifestSource.ARTIFACT], (option) => ({
+      label: capitalize(option),
+      value: option,
+    }));
+  };
+
+  private handleRawManifestChange = (rawManifest: string, manifests: any): void => {
+    this.setState({
+      rawManifest,
+    });
+    this.props.formik.setFieldValue('manifests', manifests);
+  };
+
+  private onManifestArtifactSelected = (expectedArtifactId: string): void => {
+    this.props.formik.setFieldValue('manifestArtifactId', expectedArtifactId);
+    this.props.formik.setFieldValue('manifestArtifact', null);
+  };
+
+  private onManifestArtifactEdited = (artifact: IArtifact) => {
+    this.props.formik.setFieldValue('manifestArtifactId', null);
+    this.props.formik.setFieldValue('manifestArtifact', artifact);
+  };
+
+  private getRequiredArtifacts = (): IManifestBindArtifact[] => {
+    const { requiredArtifactIds, requiredArtifacts } = this.props.formik.values;
+    return (requiredArtifactIds || [])
+      .map((id: string) => ({ expectedArtifactId: id }))
+      .concat(requiredArtifacts || []);
+  };
+
+  private onRequiredArtifactsChanged = (bindings: IManifestBindArtifact[]): void => {
+    this.props.formik.setFieldValue(
+      'requiredArtifactIds',
+      bindings.filter((b) => b.expectedArtifactId).map((b) => b.expectedArtifactId),
+    );
+    this.props.formik.setFieldValue(
+      'requiredArtifacts',
+      bindings.filter((b) => b.artifact),
+    );
+  };
+
+  public render() {
+    const stage = this.props.formik.values;
+    return (
+      <div className="form-horizontal">
+        <h4>Basic Settings</h4>
+        <ManifestBasicSettings
+          accounts={this.props.accounts}
+          onAccountSelect={(accountName) => this.props.formik.setFieldValue('account', accountName)}
+          selectedAccount={stage.account}
+        />
+        <StageConfigField label="Application">
+          <input
+            className="form-control input-sm"
+            type="text"
+            value={this.props.application.name}
+            onChange={(event) => this.props.formik.setFieldValue('application', event.target.value)}
+            disabled
+          />
+        </StageConfigField>
+        <StageConfigField label="Stack">
+          <input
+            className="form-control input-sm"
+            type="text"
+            value={stage.stack}
+            onChange={(event) => this.props.formik.setFieldValue('stack', event.target.value)}
+          />
+        </StageConfigField>
+        <StageConfigField label="Details">
+          <input
+            className="form-control input-sm"
+            type="text"
+            value={stage.details}
+            onChange={(event) => this.props.formik.setFieldValue('details', event.target.value)}
+          />
+        </StageConfigField>
+        <ServerGroupNamePreview
+          application={this.props.application.name}
+          stack={stage.stack}
+          details={stage.details}
+        ></ServerGroupNamePreview>
+
+        <hr />
+        <h4>Manifest Configuration</h4>
+        <StageConfigField label="Manifest Source" helpKey="cloudrun.manifest.source">
+          <RadioButtonInput
+            options={this.getSourceOptions()}
+            onChange={(e: any) => this.props.formik.setFieldValue('source', e.target.value)}
+            value={stage.source}
+          />
+        </StageConfigField>
+        {stage.source === ManifestSource.TEXT && (
+          <StageConfigField label="Manifest">
+            <YamlEditor onChange={this.handleRawManifestChange} value={this.state.rawManifest} />
+          </StageConfigField>
+        )}
+        {stage.source === ManifestSource.ARTIFACT && (
+          <>
+            <StageArtifactSelectorDelegate
+              artifact={stage.manifestArtifact}
+              excludedArtifactTypePatterns={this.excludedManifestArtifactTypes}
+              expectedArtifactId={stage.manifestArtifactId}
+              helpKey="cloudrun.manifest.expectedArtifact"
+              label="Manifest Artifact"
+              onArtifactEdited={this.onManifestArtifactEdited}
+              onExpectedArtifactSelected={(artifact: IExpectedArtifact) => this.onManifestArtifactSelected(artifact.id)}
+              pipeline={this.props.pipeline}
+              stage={stage}
+            />
+            <StageConfigField label="Expression Evaluation" helpKey="cloudrun.manifest.skipExpressionEvaluation">
+              <CheckboxInput
+                checked={stage.skipExpressionEvaluation === true}
+                onChange={(e: any) => this.props.formik.setFieldValue('skipExpressionEvaluation', e.target.checked)}
+                text="Skip SpEL expression evaluation"
+              />
+            </StageConfigField>
+          </>
+        )}
+        <StageConfigField label="Required Artifacts to Bind" helpKey="cloudrun.manifest.requiredArtifactsToBind">
+          <ManifestBindArtifactsSelector
+            bindings={this.getRequiredArtifacts()}
+            onChangeBindings={this.onRequiredArtifactsChanged}
+            pipeline={this.props.pipeline}
+            stage={stage}
+          />
+        </StageConfigField>
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/deployManifest/ManifestBindArtifactsSelector.tsx

@@ -0,0 +1,69 @@
+import React from 'react';
+
+import type { IArtifact, IExpectedArtifact, IPipeline, IStage } from '@spinnaker/core';
+import { ArtifactTypePatterns, StageArtifactSelector } from '@spinnaker/core';
+
+export interface IManifestBindArtifact {
+  expectedArtifactId?: string;
+  artifact?: IArtifact;
+}
+
+export interface IManifestBindArtifactsSelectorProps {
+  pipeline: IPipeline;
+  stage: IStage;
+  bindings?: IManifestBindArtifact[];
+  onChangeBindings: (_: IManifestBindArtifact[]) => void;
+}
+
+export class ManifestBindArtifactsSelector extends React.Component<IManifestBindArtifactsSelectorProps> {
+  private onChangeBinding = (index: number, binding: IManifestBindArtifact) => {
+    const bindings = (this.props.bindings || []).slice(0);
+    bindings[index] = binding;
+    this.props.onChangeBindings(bindings);
+  };
+
+  private onRemoveBinding = (index: number) => {
+    const bindings = (this.props.bindings || []).slice(0);
+    bindings.splice(index, 1);
+    this.props.onChangeBindings(bindings);
+  };
+
+  public render() {
+    const { stage, pipeline, bindings } = this.props;
+
+    const renderSelect = (i: number, binding?: IManifestBindArtifact) => {
+      const key = (!binding && 'new') || binding.expectedArtifactId || (binding.artifact && binding.artifact.id);
+      return (
+        <div className="row" key={key}>
+          <div className="col-md-10">
+            <StageArtifactSelector
+              pipeline={pipeline}
+              stage={stage}
+              expectedArtifactId={binding && binding.expectedArtifactId}
+              artifact={!!binding && binding.artifact}
+              onArtifactEdited={(artifact: IArtifact) => this.onChangeBinding(i, { artifact: artifact })}
+              onExpectedArtifactSelected={(expectedArtifact: IExpectedArtifact) =>
+                this.onChangeBinding(i, { expectedArtifactId: expectedArtifact.id })
+              }
+              excludedArtifactIds={bindings.map((b) => b.expectedArtifactId)}
+              excludedArtifactTypePatterns={[ArtifactTypePatterns.FRONT50_PIPELINE_TEMPLATE]}
+            />
+          </div>
+          {binding && (
+            <div className="col-md-2">
+              <a className="glyphicon glyphicon-trash" onClick={() => this.onRemoveBinding(i)} />
+            </div>
+          )}
+        </div>
+      );
+    };
+    const renderSelectEditable = (binding: IManifestBindArtifact, i: number) => renderSelect(i, binding);
+
+    return (
+      <>
+        {bindings.map(renderSelectEditable)}
+        {renderSelect(bindings.length)}
+      </>
+    );
+  }
+}

package/src/pipeline/stages/deployManifest/deploy.validator.ts

@@ -0,0 +1,38 @@
+import { get, isEmpty } from 'lodash';
+
+import type { ICustomValidator, IPipeline, IStage, IValidatorConfig } from '@spinnaker/core';
+
+import { ManifestSource } from '../../../manifest/ManifestSource';
+import { strategyRedBlack } from '../../../rolloutStrategy/redblack.strategy';
+
+const MAX_VERSION_HISTORY_ANNOTATION = 'strategy.spinnaker.io/max-version-history';
+
+export const deployValidators = (): IValidatorConfig[] => {
+  return [
+    { type: 'requiredField', fieldName: 'account', fieldLabel: 'Account' },
+    { type: 'requiredField', fieldName: 'source', fieldLabel: 'Source' },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, stage: IStage) => {
+        const enabled = get(stage, 'trafficManagement.enabled', false);
+        const services = get(stage, 'trafficManagement.options.services', []);
+        if (enabled && isEmpty(services)) {
+          return `Select at least one <strong>Service</strong> to enable Spinnaker-managed rollout strategy options.`;
+        }
+        if (enabled && stage.source === ManifestSource.TEXT) {
+          const manifests = get(stage, 'manifests', []);
+          const replicaSetManifests = manifests.filter((m) => m.kind === 'ReplicaSet');
+          const strategy = get(stage, 'trafficManagement.options.strategy');
+          const maxVersionHistory = parseInt(
+            get(replicaSetManifests, [0, 'metadata', 'annotations', MAX_VERSION_HISTORY_ANNOTATION]),
+            10,
+          );
+          if (strategy === strategyRedBlack.key && maxVersionHistory < 2) {
+            return `The max version history specified in your manifest conflicts with the behavior of the Red/Black rollout strategy. Please update your <strong>${MAX_VERSION_HISTORY_ANNOTATION}</strong> annotation to a value greater than or equal to 2.`;
+          }
+        }
+        return null;
+      },
+    } as ICustomValidator,
+  ];
+};

package/src/pipeline/stages/deployManifest/deployStage.ts

@@ -0,0 +1,28 @@
+import type { IStage } from '@spinnaker/core';
+import {
+  ArtifactReferenceService,
+  ExecutionArtifactTab,
+  ExecutionDetailsTasks,
+  ExpectedArtifactService,
+  Registry,
+} from '@spinnaker/core';
+
+import { DeployStageConfig } from './DeployStageConfig';
+import { deployValidators } from './deploy.validator';
+import { DeployStatus } from './manifestStatus/DeployStatus';
+
+Registry.pipeline.registerStage({
+  label: 'Deploy (Cloud Run)',
+  description: 'Deploy a Cloud Run manifest yaml/json file.',
+  key: 'deployCloudrunManifest',
+  cloudProvider: 'cloudrun',
+  component: DeployStageConfig,
+  executionDetailsSections: [DeployStatus, ExecutionDetailsTasks, ExecutionArtifactTab],
+  producesArtifacts: true,
+  supportsCustomTimeout: true,
+  validators: deployValidators(),
+  accountExtractor: (stage: IStage): string[] => (stage.account ? [stage.account] : []),
+  configAccountExtractor: (stage: any): string[] => (stage.account ? [stage.account] : []),
+  artifactExtractor: ExpectedArtifactService.accumulateArtifacts(['manifestArtifactId', 'requiredArtifactIds']),
+  artifactRemover: ArtifactReferenceService.removeArtifactFromFields(['manifestArtifactId', 'requiredArtifactIds']),
+});