@spinnaker/cloudfoundry 0.0.0-main-2

package/src/pipeline/stages/createServiceBindings/CloudFoundryCreateServiceBindingsConfig.tsx

@@ -0,0 +1,69 @@
+import type { FormikErrors } from 'formik';
+import { cloneDeep } from 'lodash';
+import React from 'react';
+
+import type { IStage, IStageConfigProps } from '@spinnaker/core';
+import { FormikStageConfig, FormValidator } from '@spinnaker/core';
+
+import { CloudFoundryCreateServiceBindingsStageConfigForm } from './CloudFoundryCreateServiceBindingsStageConfigForm';
+
+export interface ServiceBindingRequests {
+  serviceInstanceName: String;
+}
+
+export function CloudFoundryCreateServiceBindingsConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+}: IStageConfigProps) {
+  const stageWithDefaults = React.useMemo(() => {
+    return {
+      serviceBindingRequests: [],
+      restageRequired: true,
+      restartRequired: false,
+      credentials: '',
+      region: '',
+      ...cloneDeep(stage),
+    };
+  }, []);
+
+  return (
+    <FormikStageConfig
+      application={application}
+      onChange={updateStage}
+      pipeline={pipeline}
+      stage={stageWithDefaults}
+      validate={validateCloudFoundryCreateServiceBindingsStage}
+      render={(props) => <CloudFoundryCreateServiceBindingsStageConfigForm {...props} />}
+    />
+  );
+}
+
+export function validateCloudFoundryCreateServiceBindingsStage(stage: IStage): FormikErrors<IStage> {
+  const formValidator = new FormValidator(stage);
+
+  formValidator.field('credentials', 'Account').required();
+  formValidator.field('region', 'Region').required();
+  formValidator.field('cluster', 'Cluster').required();
+  formValidator.field('target', 'Target').required();
+
+  formValidator
+    .field('serviceBindingRequests', 'Service Binding Requests')
+    .required()
+    .withValidators((serviceBindingRequests: ServiceBindingRequests[]) => {
+      if (validateServiceBindingRequests(serviceBindingRequests)) {
+        return undefined;
+      }
+      return 'There should be at least one service binding request. At a minimum, each request must have a service instance name.';
+    });
+
+  return formValidator.validateForm();
+}
+
+export function validateServiceBindingRequests(serviceBindingRequests: ServiceBindingRequests[]): boolean {
+  if (serviceBindingRequests?.length < 1) {
+    return false;
+  }
+  return serviceBindingRequests.every((req) => req?.serviceInstanceName);
+}

package/src/pipeline/stages/createServiceBindings/CloudFoundryCreateServiceBindingsStageConfigForm.tsx

@@ -0,0 +1,230 @@
+import React from 'react';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { Application, IAccount, IArtifact, IFormikStageConfigInjectedProps, IRegion } from '@spinnaker/core';
+import {
+  AccountService,
+  ArtifactTypePatterns,
+  excludeAllTypesExcept,
+  NgReact,
+  StageArtifactSelectorDelegate,
+  StageConfigField,
+  StageConstants,
+  TextInput,
+} from '@spinnaker/core';
+
+import { AccountRegionClusterSelector } from '../../../presentation/widgets/accountRegionClusterSelector';
+
+interface ICloudFoundryCreateServiceBindingsStageConfigState {
+  accounts: IAccount[];
+  regions: string[];
+  application: Application;
+}
+
+export class CloudFoundryCreateServiceBindingsStageConfigForm extends React.Component<
+  IFormikStageConfigInjectedProps,
+  ICloudFoundryCreateServiceBindingsStageConfigState
+> {
+  private static readonly excludedArtifactTypes = excludeAllTypesExcept(
+    ArtifactTypePatterns.BITBUCKET_FILE,
+    ArtifactTypePatterns.CUSTOM_OBJECT,
+    ArtifactTypePatterns.EMBEDDED_BASE64,
+    ArtifactTypePatterns.GCS_OBJECT,
+    ArtifactTypePatterns.GITHUB_FILE,
+    ArtifactTypePatterns.GITLAB_FILE,
+    ArtifactTypePatterns.S3_OBJECT,
+    ArtifactTypePatterns.HTTP_FILE,
+    ArtifactTypePatterns.ORACLE_OBJECT,
+  );
+
+  private destroy$ = new Subject();
+
+  constructor(props: IFormikStageConfigInjectedProps, context: any) {
+    super(props, context);
+    this.state = {
+      accounts: [],
+      regions: [],
+      application: props.application,
+    };
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((rawAccounts: IAccount[]) => this.setState({ accounts: rawAccounts }));
+  }
+
+  public componentDidMount() {
+    const stage = this.props.formik.values;
+    this.props.formik.setFieldValue('cloudProvider', 'cloudfoundry');
+    if (stage.serviceBindingRequests && stage.serviceBindingRequests.length === 0) {
+      this.props.formik.setFieldValue('serviceBindingRequests', [
+        {
+          serviceInstanceName: '',
+          updatable: false,
+        },
+      ]);
+    }
+    if (stage.credentials) {
+      this.loadRegions(stage.credentials);
+    }
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private loadRegions = (creds: string) => {
+    this.setState({ regions: [] });
+    observableFrom(AccountService.getRegionsForAccount(creds))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((regionList: IRegion[]) => {
+        const regions = regionList.map((r) => r.name);
+        regions.sort((a, b) => a.localeCompare(b));
+        this.setState({ regions: regions });
+      });
+  };
+
+  private onTemplateArtifactEdited = (artifact: IArtifact, index: number) => {
+    this.props.formik.setFieldValue(`serviceBindingRequests[${index}].id`, null);
+    this.props.formik.setFieldValue(`serviceBindingRequests[${index}].artifact`, artifact);
+  };
+
+  private onTemplateArtifactSelected = (id: string, index: number) => {
+    this.props.formik.setFieldValue(`serviceBindingRequests[${index}].id`, id);
+    this.props.formik.setFieldValue(`serviceBindingRequests[${index}].artifact`, null);
+  };
+
+  private addInputArtifact = () => {
+    const stage = this.props.formik.values;
+    const newServiceBindingRequests = [
+      ...stage.serviceBindingRequests,
+      {
+        serviceInstanceName: '',
+        updatable: false,
+      },
+    ];
+
+    this.props.formik.setFieldValue('serviceBindingRequests', newServiceBindingRequests);
+  };
+
+  private removeInputArtifact = (index: number) => {
+    const stage = this.props.formik.values;
+    const newServiceBindingRequests = [...stage.serviceBindingRequests];
+    newServiceBindingRequests.splice(index, 1);
+    this.props.formik.setFieldValue('serviceBindingRequests', newServiceBindingRequests);
+  };
+
+  private targetUpdated = (target: string) => {
+    this.props.formik.setFieldValue('target', target);
+  };
+
+  private restageRequiredUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.formik.setFieldValue('restageRequired', event.target.checked);
+    this.props.formik.setFieldValue('restartRequired', !event.target.checked);
+  };
+
+  private restartRequiredUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.formik.setFieldValue('restartRequired', event.target.checked);
+    this.props.formik.setFieldValue('restageRequired', !event.target.checked);
+  };
+
+  private updatableBindingUpdated = (event: React.ChangeEvent<HTMLInputElement>, index: number) => {
+    this.props.formik.setFieldValue(`serviceBindingRequests[${index}].updatable`, event.target.checked);
+  };
+
+  private accountRegionClusterUpdated = (stage: any): void => {
+    this.props.formik.setFieldValue(`cluster`, stage.cluster);
+    this.props.formik.setFieldValue(`credentials`, stage.credentials);
+    this.props.formik.setFieldValue(`region`, stage.region);
+  };
+
+  public render() {
+    const stage = this.props.formik.values;
+    const { accounts, application } = this.state;
+    const { target } = stage;
+    const { TargetSelect } = NgReact;
+
+    return (
+      <>
+        <h4>Basic Settings</h4>
+        <div className="form-horizontal">
+          <AccountRegionClusterSelector
+            accounts={accounts}
+            application={application}
+            cloudProvider={'cloudfoundry'}
+            isSingleRegion={true}
+            onComponentUpdate={this.accountRegionClusterUpdated}
+            component={stage}
+          />
+        </div>
+        <StageConfigField label="Target">
+          <TargetSelect model={{ target }} options={StageConstants.TARGET_LIST} onChange={this.targetUpdated} />
+        </StageConfigField>
+        <StageConfigField label="Restage Required">
+          <input type="checkbox" checked={stage.restageRequired} onChange={this.restageRequiredUpdated} />
+        </StageConfigField>
+        <StageConfigField label="Restart Required">
+          <input type="checkbox" checked={stage.restartRequired} onChange={this.restartRequiredUpdated} />
+        </StageConfigField>
+        <h4>Service Bindings</h4>
+        {stage.serviceBindingRequests && stage.serviceBindingRequests.length > 0 && (
+          <div className="row form-group">
+            {stage.serviceBindingRequests.map((a: any, index: number) => {
+              return (
+                <div key={index}>
+                  <div className="col-md-offset-1 col-md-8">
+                    <StageConfigField label="Service Instance Name">
+                      <TextInput
+                        onChange={(e: React.ChangeEvent<any>) => {
+                          this.props.formik.setFieldValue(
+                            `serviceBindingRequests[${index}].serviceInstanceName`,
+                            e.target.value,
+                          );
+                        }}
+                        value={a.serviceInstanceName}
+                      />
+                    </StageConfigField>
+                    <StageArtifactSelectorDelegate
+                      artifact={a.artifact}
+                      excludedArtifactTypePatterns={
+                        CloudFoundryCreateServiceBindingsStageConfigForm.excludedArtifactTypes
+                      }
+                      expectedArtifactId={a.id}
+                      label="Service Binding Parameters"
+                      onArtifactEdited={(artifact) => {
+                        this.onTemplateArtifactEdited(artifact, index);
+                      }}
+                      onExpectedArtifactSelected={(artifact) => this.onTemplateArtifactSelected(artifact.id, index)}
+                      pipeline={this.props.pipeline}
+                      stage={stage}
+                    />
+                    <StageConfigField label="Updatable Binding">
+                      <input
+                        type="checkbox"
+                        checked={a.updatable}
+                        onChange={(event) => this.updatableBindingUpdated(event, index)}
+                      />
+                    </StageConfigField>
+                  </div>
+                  <div className="col-md-1">
+                    <div className="form-control-static">
+                      <button onClick={() => this.removeInputArtifact(index)}>
+                        <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 Service Binding
+          </button>
+        </StageConfigField>
+      </>
+    );
+  }
+}

package/src/pipeline/stages/createServiceBindings/cloudFoundryCreateServiceBindingsStage.ts

@@ -0,0 +1,19 @@
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import {
+  CloudFoundryCreateServiceBindingsConfig,
+  validateCloudFoundryCreateServiceBindingsStage,
+} from './CloudFoundryCreateServiceBindingsConfig';
+
+export const CF_CREATE_SERVICE_BINDINGS_STAGE_KEY = 'cloudFoundryCreateServiceBindings';
+
+Registry.pipeline.registerStage({
+  label: 'Create Service Bindings',
+  description: 'Create CF service bindings with optional parameters.',
+  key: CF_CREATE_SERVICE_BINDINGS_STAGE_KEY,
+  component: CloudFoundryCreateServiceBindingsConfig,
+  producesArtifacts: false,
+  cloudProvider: 'cloudfoundry',
+  executionDetailsSections: [ExecutionDetailsTasks],
+  validateFn: validateCloudFoundryCreateServiceBindingsStage,
+});

package/src/pipeline/stages/createServiceBindings/cloudFoundryCreateServiceBindingsStageForm.spec.tsx

@@ -0,0 +1,50 @@
+import { mock } from 'angular';
+import type { IStage } from 'core';
+import { ApplicationModelBuilder, REACT_MODULE, SpinFormik, StageConfigField } from 'core';
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { mockServerGroupDataSourceConfig } from '@spinnaker/mocks';
+
+import { CloudFoundryCreateServiceBindingsStageConfigForm } from './CloudFoundryCreateServiceBindingsStageConfigForm';
+
+describe('<CloudFoundryCreateServiceBindingsStageConfigForm/>', function () {
+  beforeEach(mock.module(REACT_MODULE));
+  beforeEach(mock.inject());
+
+  const getProps = () => {
+    return {
+      application: ApplicationModelBuilder.createApplicationForTests('my-application', mockServerGroupDataSourceConfig),
+      pipeline: {
+        application: 'my-application',
+        id: 'pipeline-id',
+        limitConcurrent: true,
+        keepWaitingPipelines: true,
+        name: 'My Pipeline',
+        parameterConfig: [],
+        stages: [],
+        triggers: [],
+      },
+    } as any;
+  };
+
+  it('loads component correctly with 2 serviceBindingRequests', function () {
+    const stage = ({
+      serviceBindingRequests: [{ serviceInstanceName: 'service1' }, { serviceInstanceName: 'service2' }],
+    } as unknown) as IStage;
+
+    const props = getProps();
+    const component = mount(
+      <SpinFormik
+        initialValues={stage}
+        onSubmit={() => null}
+        validate={() => null}
+        render={(formik) => <CloudFoundryCreateServiceBindingsStageConfigForm {...props} formik={formik} />}
+      />,
+    );
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === 'Target').length).toBe(1);
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === 'Restage Required').length).toBe(1);
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === 'Restart Required').length).toBe(1);
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === 'Service Instance Name').length).toBe(2);
+  });
+});

package/src/pipeline/stages/createServiceKey/CloudFoundryCreateServiceKeyStageConfig.tsx

@@ -0,0 +1,116 @@
+import React from 'react';
+import type { Option } from 'react-select';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { IAccount, IRegion, IStageConfigProps } from '@spinnaker/core';
+import { AccountService, ReactSelectInput, StageConfigField, TextInput } from '@spinnaker/core';
+
+interface ICloudFoundryCreateServiceKeyStageConfigState {
+  accounts: string[];
+  regions: string[];
+}
+
+export class CloudFoundryCreateServiceKeyStageConfig extends React.Component<
+  IStageConfigProps,
+  ICloudFoundryCreateServiceKeyStageConfigState
+> {
+  private destroy$ = new Subject();
+
+  constructor(props: IStageConfigProps) {
+    super(props);
+    props.stage.cloudProvider = 'cloudfoundry';
+    this.state = {
+      accounts: [],
+      regions: [],
+    };
+  }
+
+  public componentDidMount(): void {
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((rawAccounts: IAccount[]) => this.setState({ accounts: rawAccounts.map((it) => it.name) }));
+    if (this.props.stage.credentials) {
+      this.clearAndReloadRegions();
+    }
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private clearAndReloadRegions = () => {
+    this.setState({ regions: [] });
+    observableFrom(AccountService.getRegionsForAccount(this.props.stage.credentials))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((regionList: IRegion[]) => {
+        const regions = regionList.map((r) => r.name);
+        regions.sort((a, b) => a.localeCompare(b));
+        this.setState({ regions });
+      });
+  };
+
+  private serviceInstanceNameUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.updateStageField({ serviceInstanceName: event.target.value });
+  };
+
+  private serviceKeyNameUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.updateStageField({ serviceKeyName: event.target.value });
+  };
+
+  private accountUpdated = (option: Option<string>) => {
+    const credentials = option.target.value;
+    this.setState({
+      regions: [],
+    });
+    this.props.updateStageField({
+      credentials,
+      region: '',
+    });
+    this.clearAndReloadRegions();
+  };
+
+  private regionUpdated = (option: Option<string>) => {
+    const region = option.target.value;
+    this.props.updateStageField({
+      region,
+    });
+  };
+
+  public render() {
+    const { credentials, region, serviceInstanceName, serviceKeyName } = this.props.stage;
+    const { accounts, regions } = this.state;
+
+    return (
+      <div className="form-horizontal">
+        <StageConfigField label="Account">
+          <ReactSelectInput
+            clearable={false}
+            onChange={this.accountUpdated}
+            value={credentials}
+            stringOptions={accounts}
+          />
+        </StageConfigField>
+        <StageConfigField label="Region">
+          <ReactSelectInput clearable={false} onChange={this.regionUpdated} value={region} stringOptions={regions} />
+        </StageConfigField>
+        <StageConfigField label="Service Instance Name">
+          <TextInput
+            type="text"
+            className="form-control"
+            onChange={this.serviceInstanceNameUpdated}
+            value={serviceInstanceName}
+          />
+        </StageConfigField>
+        <StageConfigField label="Service Key Name">
+          <TextInput
+            type="text"
+            className="form-control"
+            onChange={this.serviceKeyNameUpdated}
+            value={serviceKeyName}
+          />
+        </StageConfigField>
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/createServiceKey/cloudFoundryCreateServiceKeyStage.module.ts

@@ -0,0 +1,21 @@
+import type { IStage } from '@spinnaker/core';
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { CloudFoundryCreateServiceKeyStageConfig } from './CloudFoundryCreateServiceKeyStageConfig';
+import { CloudFoundryServiceKeyExecutionDetails } from '../../../presentation';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryCreateServiceKeyStageConfig,
+  description: 'Create a service key',
+  executionDetailsSections: [CloudFoundryServiceKeyExecutionDetails, ExecutionDetailsTasks],
+  key: 'createServiceKey',
+  label: 'Create Service Key',
+  validators: [
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+    { type: 'requiredField', fieldName: 'region', preventSave: true },
+    { type: 'requiredField', fieldName: 'serviceInstanceName', preventSave: true },
+    { type: 'requiredField', fieldName: 'serviceKeyName', preventSave: true },
+  ],
+});

package/src/pipeline/stages/deleteServiceBindings/CloudFoundryDeleteServiceBindingsConfig.tsx

@@ -0,0 +1,69 @@
+import type { FormikErrors } from 'formik';
+import { cloneDeep } from 'lodash';
+import React from 'react';
+
+import type { IStage, IStageConfigProps } from '@spinnaker/core';
+import { FormikStageConfig, FormValidator } from '@spinnaker/core';
+
+import { CloudFoundryDeleteServiceBindingsStageConfigForm } from './CloudFoundryDeleteServiceBindingsStageConfigForm';
+
+interface ServiceUnbindingRequests {
+  serviceInstanceName: String;
+}
+
+export function CloudFoundryDeleteServiceBindingsConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+}: IStageConfigProps) {
+  const stageWithDefaults = React.useMemo(() => {
+    return {
+      serviceUnbindingRequests: [],
+      restageRequired: true,
+      restartRequired: false,
+      credentials: '',
+      region: '',
+      ...cloneDeep(stage),
+    };
+  }, []);
+
+  return (
+    <FormikStageConfig
+      application={application}
+      onChange={updateStage}
+      pipeline={pipeline}
+      stage={stageWithDefaults}
+      validate={validateCloudFoundryDeleteServiceBindingsStage}
+      render={(props) => <CloudFoundryDeleteServiceBindingsStageConfigForm {...props} />}
+    />
+  );
+}
+
+export function validateCloudFoundryDeleteServiceBindingsStage(stage: IStage): FormikErrors<IStage> {
+  const formValidator = new FormValidator(stage);
+
+  formValidator.field('credentials', 'Account').required();
+  formValidator.field('region', 'Region').required();
+  formValidator.field('cluster', 'Cluster').required();
+  formValidator.field('target', 'Target').required();
+
+  formValidator
+    .field('serviceUnbindingRequests', 'Service Binding Requests')
+    .required()
+    .withValidators((serviceUnbindingRequests: ServiceUnbindingRequests[]) => {
+      if (validateServiceUnbindingRequests(serviceUnbindingRequests)) {
+        return undefined;
+      }
+      return 'There should be at least one service binding request. At a minimum, each request must have a service instance name.';
+    });
+
+  return formValidator.validateForm();
+}
+
+export function validateServiceUnbindingRequests(serviceUnbindingRequests: ServiceUnbindingRequests[]): boolean {
+  if (serviceUnbindingRequests?.length < 1) {
+    return false;
+  }
+  return serviceUnbindingRequests.every((req) => req.serviceInstanceName);
+}