@spinnaker/cloudfoundry 0.0.0-main-2

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

@@ -0,0 +1,158 @@
+import React from 'react';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { Application, IAccount, IFormikStageConfigInjectedProps, IRegion } from '@spinnaker/core';
+import { AccountService, NgReact, StageConfigField, StageConstants, TextInput } from '@spinnaker/core';
+
+import { AccountRegionClusterSelector } from '../../../presentation/widgets/accountRegionClusterSelector';
+
+interface ICloudFoundryDeleteServiceBindingsStageConfigState {
+  accounts: IAccount[];
+  regions: string[];
+  application: Application;
+}
+
+export class CloudFoundryDeleteServiceBindingsStageConfigForm extends React.Component<
+  IFormikStageConfigInjectedProps,
+  ICloudFoundryDeleteServiceBindingsStageConfigState
+> {
+  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.serviceUnbindingRequests && stage.serviceUnbindingRequests.length === 0) {
+      this.props.formik.setFieldValue('serviceUnbindingRequests', [
+        {
+          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 addInputArtifact = () => {
+    const stage = this.props.formik.values;
+    const newServiceUnbindingRequests = [
+      ...stage.serviceUnbindingRequests,
+      {
+        serviceInstanceName: '',
+        updatable: false,
+      },
+    ];
+
+    this.props.formik.setFieldValue('serviceUnbindingRequests', newServiceUnbindingRequests);
+  };
+
+  private removeInputArtifact = (index: number) => {
+    const stage = this.props.formik.values;
+    const newServiceUnbindingRequests = [...stage.serviceUnbindingRequests];
+    newServiceUnbindingRequests.splice(index, 1);
+    this.props.formik.setFieldValue('serviceUnbindingRequests', newServiceUnbindingRequests);
+  };
+
+  private targetUpdated = (target: string) => {
+    this.props.formik.setFieldValue('target', target);
+  };
+
+  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>
+        <h4>Service Unbindings</h4>
+        {stage.serviceUnbindingRequests && stage.serviceUnbindingRequests.length > 0 && (
+          <div className="row form-group">
+            {stage.serviceUnbindingRequests.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(
+                            `serviceUnbindingRequests[${index}].serviceInstanceName`,
+                            e.target.value,
+                          );
+                        }}
+                        value={a.serviceInstanceName}
+                      />
+                    </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 Unbinding
+          </button>
+        </StageConfigField>
+      </>
+    );
+  }
+}

package/src/pipeline/stages/deleteServiceBindings/cloudFoundryDeleteServiceBindingsStage.ts

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

package/src/pipeline/stages/deleteServiceBindings/cloudFoundryDeleteServiceBindingsStageForm.spec.tsx

@@ -0,0 +1,49 @@
+import { mock } from 'angular';
+import { mount } from 'enzyme';
+import React from 'react';
+
+import type { IStage } from '@spinnaker/core';
+import { ApplicationModelBuilder, REACT_MODULE, SpinFormik, StageConfigField } from '@spinnaker/core';
+import { mockServerGroupDataSourceConfig } from '@spinnaker/mocks';
+
+import { CloudFoundryDeleteServiceBindingsStageConfigForm } from './CloudFoundryDeleteServiceBindingsStageConfigForm';
+
+describe('<CloudFoundryDeleteServiceBindingsStageConfigForm/>', 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 serviceUnbindingRequests', function () {
+    const stage = ({
+      serviceUnbindingRequests: [{ serviceInstanceName: 'service1' }, { serviceInstanceName: 'service2' }],
+    } as unknown) as IStage;
+
+    const props = getProps();
+
+    const component = mount(
+      <SpinFormik
+        initialValues={stage}
+        onSubmit={() => null}
+        validate={() => null}
+        render={(formik) => <CloudFoundryDeleteServiceBindingsStageConfigForm {...props} formik={formik} />}
+      />,
+    );
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === 'Target').length).toBe(1);
+    expect(component.find(StageConfigField).findWhere((x) => x.text() === 'Service Instance Name').length).toBe(2);
+  });
+});

package/src/pipeline/stages/deleteServiceKey/CloudFoundryDeleteServiceKeyStageConfig.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 ICloudFoundryDeleteServiceKeyStageConfigState {
+  accounts: string[];
+  regions: string[];
+}
+
+export class CloudFoundryDeleteServiceKeyStageConfig extends React.Component<
+  IStageConfigProps,
+  ICloudFoundryDeleteServiceKeyStageConfigState
+> {
+  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/deleteServiceKey/cloudFoundryDeleteServiceKeyStage.module.ts

@@ -0,0 +1,22 @@
+import type { IStage } from '@spinnaker/core';
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { CloudFoundryDeleteServiceKeyStageConfig } from './CloudFoundryDeleteServiceKeyStageConfig';
+import { CloudFoundryServiceKeyExecutionDetails } from '../../../presentation';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryDeleteServiceKeyStageConfig,
+  description: 'Delete a service key',
+  executionDetailsSections: [CloudFoundryServiceKeyExecutionDetails, ExecutionDetailsTasks],
+  key: 'deleteServiceKey',
+  label: 'Delete 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/deployService/CloudFoundryDeployServiceStageConfig.tsx

@@ -0,0 +1,198 @@
+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, IArtifact, IExpectedArtifact, IRegion, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountService,
+  ArtifactTypePatterns,
+  ReactSelectInput,
+  StageArtifactSelector,
+  StageConfigField,
+} from '@spinnaker/core';
+
+import { CreateServiceInstanceDirectInput } from './CreateServiceInstanceDirectInput';
+import { CreateUserProvidedInput } from './CreateUserProvidedInput';
+import type { ICloudFoundryServiceManifestSource } from './ICloudFoundryServiceManifestSource';
+
+import './cloudfoundryDeployServiceStage.less';
+
+interface ICloudFoundryDeployServiceStageConfigState {
+  regions: IRegion[];
+  accounts: IAccount[];
+}
+
+export class CloudFoundryDeployServiceStageConfig extends React.Component<
+  IStageConfigProps,
+  ICloudFoundryDeployServiceStageConfigState
+> {
+  private defaultDirectManifest = {
+    direct: {
+      parameters: '',
+      service: '',
+      serviceInstanceName: '',
+      servicePlan: '',
+      updatable: false,
+      versioned: false,
+    },
+  };
+  private destroy$ = new Subject();
+
+  constructor(props: IStageConfigProps) {
+    super(props);
+    this.props.updateStageField({ cloudProvider: 'cloudfoundry' });
+    this.state = {
+      accounts: [],
+      regions: [],
+    };
+  }
+
+  private accountUpdated = (option: Option<string>): void => {
+    const credentials = option.target.value;
+    const updates: any = { credentials: credentials, region: '' };
+    if (!this.props.stage.manifest || this.props.stage.manifest.direct) {
+      updates.manifest = this.defaultDirectManifest;
+    }
+    this.props.updateStageField(updates);
+    this.reloadRegions();
+  };
+
+  public componentDidMount(): void {
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((accounts) => this.setState({ accounts }));
+    this.reloadRegions();
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private reloadRegions = () => {
+    const { credentials } = this.props.stage;
+    if (credentials) {
+      observableFrom(AccountService.getRegionsForAccount(credentials))
+        .pipe(takeUntil(this.destroy$))
+        .subscribe((regions) => this.setState({ regions }));
+    }
+  };
+
+  private manifestSourceUpdated = (source: string): void => {
+    switch (source) {
+      case 'direct':
+        this.props.updateStageField({ manifest: this.defaultDirectManifest });
+        break;
+      case 'artifact':
+        this.props.updateStageField({ manifest: {} });
+        break;
+    }
+  };
+
+  private onExpectedArtifactSelected = (expectedArtifact: IExpectedArtifact): void => {
+    this.props.updateStageField({ manifest: { artifactId: expectedArtifact.id } });
+  };
+
+  private onArtifactChanged = (artifact: IArtifact): void => {
+    this.props.updateStageField({ manifest: { artifact } });
+  };
+
+  private regionUpdated = (option: Option<string>): void => {
+    const updates: any = { region: option.target.value };
+    const direct = this.props.stage.manifest.direct;
+    if (direct) {
+      updates.manifest = this.defaultDirectManifest;
+    }
+    this.props.updateStageField(updates);
+  };
+
+  private serviceManifestSourceUpdated = (manifest: ICloudFoundryServiceManifestSource) => {
+    this.props.updateStageField({ manifest });
+  };
+
+  private userProvidedUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    this.props.updateStageField({ userProvided: event.target.checked });
+  };
+
+  public render() {
+    const { pipeline, stage } = this.props;
+    const { credentials, region, userProvided, manifest } = this.props.stage;
+    const { accounts, regions } = this.state;
+    const directInput = !manifest || !!manifest.direct;
+    let manifestInput;
+
+    if (directInput) {
+      const directManifest = (manifest && manifest.direct) || this.defaultDirectManifest;
+      manifestInput = userProvided ? (
+        <CreateUserProvidedInput
+          onChange={this.serviceManifestSourceUpdated}
+          service={directManifest}
+          onServiceChanged={(direct) => this.serviceManifestSourceUpdated({ direct })}
+        />
+      ) : (
+        <CreateServiceInstanceDirectInput
+          credentials={credentials}
+          region={region}
+          service={directManifest}
+          onServiceChanged={(direct) => this.serviceManifestSourceUpdated({ direct })}
+        />
+      );
+    } else {
+      manifestInput = (
+        <StageConfigField label="Artifact">
+          <StageArtifactSelector
+            pipeline={pipeline}
+            stage={stage}
+            expectedArtifactId={manifest.artifactId}
+            excludedArtifactTypePatterns={[
+              ArtifactTypePatterns.KUBERNETES,
+              ArtifactTypePatterns.FRONT50_PIPELINE_TEMPLATE,
+              ArtifactTypePatterns.DOCKER_IMAGE,
+            ]}
+            artifact={manifest.artifact}
+            onExpectedArtifactSelected={this.onExpectedArtifactSelected}
+            onArtifactEdited={this.onArtifactChanged}
+          />
+        </StageConfigField>
+      );
+    }
+
+    return (
+      <div className="form-horizontal cloudfoundry-deploy-service-stage">
+        <StageConfigField label="Account">
+          <ReactSelectInput
+            clearable={false}
+            onChange={this.accountUpdated}
+            value={credentials}
+            stringOptions={accounts.map((it) => it.name)}
+          />
+        </StageConfigField>
+        <StageConfigField label="Region">
+          <ReactSelectInput
+            clearable={false}
+            onChange={this.regionUpdated}
+            value={region}
+            stringOptions={regions.map((it) => it.name)}
+          />
+        </StageConfigField>
+        <StageConfigField label="User-provided">
+          <input type="checkbox" checked={!!userProvided} onChange={this.userProvidedUpdated} />
+        </StageConfigField>
+        <StageConfigField label="Configuration Source">
+          <div className="radio radio-inline">
+            <label>
+              <input type="radio" checked={!directInput} onChange={() => this.manifestSourceUpdated('artifact')} />{' '}
+              Manifest
+            </label>
+          </div>
+          <div className="radio radio-inline">
+            <label>
+              <input type="radio" checked={directInput} onChange={() => this.manifestSourceUpdated('direct')} /> Form
+            </label>
+          </div>
+        </StageConfigField>
+        {manifestInput}
+      </div>
+    );
+  }
+}