@spinnaker/cloudfoundry 0.0.0-main-2

package/src/pipeline/stages/deployService/CreateServiceInstanceDirectInput.tsx

@@ -0,0 +1,164 @@
+import React from 'react';
+import type { Option } from 'react-select';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { IService, IServicePlan } from '@spinnaker/core';
+import { ReactSelectInput, ServicesReader, StageConfigField, TextAreaInput, TextInput } from '@spinnaker/core';
+
+import type { ICloudFoundryServiceManifestDirectSource } from './ICloudFoundryServiceManifestSource';
+import { ServiceTagsInput } from './ServiceTagsInput';
+
+interface ICreateServiceInstanceDirectInputProps {
+  credentials: string;
+  region: string;
+  service: ICloudFoundryServiceManifestDirectSource;
+  onServiceChanged: (_: ICloudFoundryServiceManifestDirectSource) => void;
+}
+
+interface ICreateServiceInstanceDirectInputState {
+  serviceNamesAndPlans: IService[];
+}
+
+export class CreateServiceInstanceDirectInput extends React.Component<
+  ICreateServiceInstanceDirectInputProps,
+  ICreateServiceInstanceDirectInputState
+> {
+  private destroy$ = new Subject();
+  constructor(props: ICreateServiceInstanceDirectInputProps) {
+    super(props);
+    this.state = { serviceNamesAndPlans: [] };
+  }
+
+  public componentDidUpdate(prevProps: Readonly<ICreateServiceInstanceDirectInputProps>) {
+    const { credentials, region } = this.props;
+    if ((credentials && credentials !== prevProps.credentials) || region !== prevProps.region) {
+      this.loadServices(credentials, region);
+    }
+  }
+
+  public componentDidMount(): void {
+    this.loadServices(this.props.credentials, this.props.region);
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private loadServices(credentials: string, region: string) {
+    if (credentials && region) {
+      observableFrom(ServicesReader.getServices(credentials, region))
+        .pipe(takeUntil(this.destroy$))
+        .subscribe((serviceNamesAndPlans) => this.setState({ serviceNamesAndPlans }));
+    }
+  }
+
+  private serviceInstanceNameUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      serviceInstanceName: event.target.value,
+    });
+  };
+
+  private serviceUpdated = (option: Option<string>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      service: option.target.value,
+      servicePlan: '',
+    });
+  };
+
+  private servicePlanUpdated = (option: Option<string>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      servicePlan: option.target.value,
+    });
+  };
+
+  private parametersUpdated = (event: React.ChangeEvent<HTMLTextAreaElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      parameters: event.target.value,
+    });
+  };
+
+  private tagsUpdated = (tags: string[]) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      tags: tags,
+    });
+  };
+
+  private updatableUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      updatable: event.target.checked,
+      versioned: false,
+    });
+  };
+
+  private versionedUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      versioned: event.target.checked,
+      updatable: false,
+    });
+  };
+
+  public render() {
+    const { service } = this.props;
+    const services = this.state.serviceNamesAndPlans.map((item) => item.name);
+    const serviceWithPlans = this.state.serviceNamesAndPlans.find((it) => it.name === service.service);
+    const servicePlans = serviceWithPlans ? serviceWithPlans.servicePlans.map((it: IServicePlan) => it.name) : [];
+    return (
+      <div>
+        <StageConfigField label="Service Instance Name">
+          <TextInput
+            type="text"
+            className="form-control"
+            onChange={this.serviceInstanceNameUpdated}
+            value={service.serviceInstanceName}
+          />
+        </StageConfigField>
+        <StageConfigField label="Service">
+          <ReactSelectInput
+            clearable={false}
+            onChange={this.serviceUpdated}
+            value={service.service}
+            stringOptions={services}
+          />
+        </StageConfigField>
+        <StageConfigField label="Service Plan">
+          <ReactSelectInput
+            clearable={false}
+            onChange={this.servicePlanUpdated}
+            value={service.servicePlan}
+            stringOptions={servicePlans}
+          />
+        </StageConfigField>
+        <StageConfigField label="Tags">
+          <ServiceTagsInput tags={service.tags || []} onChange={this.tagsUpdated} />
+        </StageConfigField>
+        <StageConfigField label="Parameters">
+          <TextAreaInput className="form-control" onChange={this.parametersUpdated} value={service.parameters || ''} />
+        </StageConfigField>
+        <StageConfigField label="Updatable" helpKey={'pipeline.config.cf.createservice.updatable'}>
+          <input
+            type="checkbox"
+            disabled={!!service.versioned}
+            checked={!!service.updatable}
+            onChange={this.updatableUpdated}
+          />
+        </StageConfigField>
+        <StageConfigField label="Versioned" helpKey={'pipeline.config.cf.createservice.versioned'}>
+          <input
+            type="checkbox"
+            disabled={!!service.updatable}
+            checked={!!service.versioned}
+            onChange={this.versionedUpdated}
+          />
+        </StageConfigField>
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/deployService/CreateUserProvidedInput.tsx

@@ -0,0 +1,116 @@
+import React from 'react';
+
+import { StageConfigField, TextAreaInput, TextInput } from '@spinnaker/core';
+
+import type {
+  ICloudFoundryServiceManifestSource,
+  ICloudFoundryServiceUserProvidedSource,
+} from './ICloudFoundryServiceManifestSource';
+import { ServiceTagsInput } from './ServiceTagsInput';
+
+interface ICreateServiceInstanceUserProvidedInputProps {
+  onChange: (serviceInput: ICloudFoundryServiceManifestSource) => void;
+  service: ICloudFoundryServiceUserProvidedSource;
+  onServiceChanged: (_: ICloudFoundryServiceUserProvidedSource) => void;
+}
+
+export class CreateUserProvidedInput extends React.Component<ICreateServiceInstanceUserProvidedInputProps> {
+  constructor(props: ICreateServiceInstanceUserProvidedInputProps) {
+    super(props);
+  }
+
+  private serviceInstanceNameUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      serviceInstanceName: event.target.value,
+    });
+  };
+
+  private syslogDrainUrlUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      syslogDrainUrl: event.target.value,
+    });
+  };
+
+  private routeServiceUrlUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      routeServiceUrl: event.target.value,
+    });
+  };
+
+  private credentialsUpdated = (event: React.ChangeEvent<HTMLTextAreaElement>): void => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      credentials: event.target.value,
+    });
+  };
+
+  private tagsUpdated = (tags: string[]) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      tags: tags,
+    });
+  };
+
+  private updatableUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      updatable: event.target.checked,
+      versioned: false,
+    });
+  };
+
+  private versionedUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.onServiceChanged({
+      ...this.props.service,
+      versioned: event.target.checked,
+      updatable: false,
+    });
+  };
+
+  public render() {
+    const { service } = this.props;
+    return (
+      <>
+        <StageConfigField label="Service Instance Name">
+          <TextInput
+            type="text"
+            className="form-control"
+            onChange={this.serviceInstanceNameUpdated}
+            value={service.serviceInstanceName}
+          />
+        </StageConfigField>
+        <StageConfigField label="Syslog Drain URL">
+          <TextInput onChange={this.syslogDrainUrlUpdated} value={service.syslogDrainUrl} />
+        </StageConfigField>
+        <StageConfigField label="Route Service URL">
+          <TextInput onChange={this.routeServiceUrlUpdated} value={service.routeServiceUrl} />
+        </StageConfigField>
+        <StageConfigField label="Credentials">
+          <TextAreaInput onChange={this.credentialsUpdated} value={service.credentials} />
+        </StageConfigField>
+        <StageConfigField label="Tags">
+          <ServiceTagsInput tags={service.tags || []} onChange={this.tagsUpdated} />
+        </StageConfigField>
+        <StageConfigField label="Updatable" helpKey={'pipeline.config.cf.createservice.updatable'}>
+          <input
+            type="checkbox"
+            disabled={!!service.versioned}
+            checked={!!service.updatable}
+            onChange={this.updatableUpdated}
+          />
+        </StageConfigField>
+        <StageConfigField label="Versioned" helpKey={'pipeline.config.cf.createservice.versioned'}>
+          <input
+            type="checkbox"
+            disabled={!!service.updatable}
+            checked={!!service.versioned}
+            onChange={this.versionedUpdated}
+          />
+        </StageConfigField>
+      </>
+    );
+  }
+}

package/src/pipeline/stages/deployService/ICloudFoundryServiceManifestSource.ts

@@ -0,0 +1,27 @@
+import type { IArtifact } from '@spinnaker/core';
+
+export interface ICloudFoundryServiceManifestDirectSource {
+  parameters?: string;
+  service: string;
+  serviceInstanceName: string;
+  servicePlan: string;
+  tags?: string[];
+  updatable: boolean;
+  versioned: boolean;
+}
+
+export interface ICloudFoundryServiceUserProvidedSource {
+  credentials?: string;
+  routeServiceUrl: string;
+  serviceInstanceName: string;
+  syslogDrainUrl?: string;
+  tags?: string[];
+  updatable: boolean;
+  versioned: boolean;
+}
+
+export interface ICloudFoundryServiceManifestSource {
+  artifact?: IArtifact;
+  artifactId?: string;
+  direct?: ICloudFoundryServiceManifestDirectSource | ICloudFoundryServiceUserProvidedSource;
+}

package/src/pipeline/stages/deployService/ServiceTagsInput.tsx

@@ -0,0 +1,89 @@
+import { includes } from 'lodash';
+import React from 'react';
+
+interface IServiceTagsInputProps {
+  tags: string[];
+  onChange: (e: string[]) => void;
+}
+
+interface IServiceTagsInputState {
+  newTag: string;
+  tags: string[];
+}
+
+export class ServiceTagsInput extends React.Component<IServiceTagsInputProps, IServiceTagsInputState> {
+  constructor(props: IServiceTagsInputProps) {
+    super(props);
+    this.state = {
+      newTag: '',
+      tags: this.props.tags || [],
+    };
+  }
+
+  private newTagUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    this.setState({ newTag: event.target.value });
+  };
+
+  private addTag = (): void => {
+    const { onChange, tags } = this.props;
+    const { newTag } = this.state;
+    const currentTags = tags || [];
+
+    if (!includes(currentTags, newTag.trim())) {
+      const newTags = [...currentTags, newTag.trim()].sort((a, b) => a.localeCompare(b));
+      this.setState({
+        tags: newTags,
+        newTag: '',
+      });
+      onChange(newTags);
+    }
+  };
+
+  private deleteTag = (index: number): void => {
+    const { onChange, tags } = this.props;
+    const newTags = tags.slice();
+    newTags.splice(index, 1);
+    this.setState({ tags: newTags });
+    onChange(newTags);
+  };
+
+  public render() {
+    const { tags, newTag } = this.state;
+    return (
+      <>
+        <div className="row">
+          <div className="col-md-4">
+            <input type="text" className="form-control" name="newTag" onChange={this.newTagUpdated} value={newTag} />
+          </div>
+          <div className="col-md-2">
+            <button disabled={!newTag.trim()} className="btn btn-default btn-sm btn-add-tag" onClick={this.addTag}>
+              Add Tag
+            </button>
+          </div>
+        </div>
+        <div>
+          <div>
+            {tags &&
+              tags.map((tag: any, index: number) => {
+                return (
+                  <span className="badge badge-pill" key={index}>
+                    &nbsp;
+                    {tag}
+                    &nbsp;
+                    <button
+                      type="button"
+                      className="close small"
+                      aria-label="Close"
+                      onClick={() => this.deleteTag(index)}
+                    >
+                      <span aria-hidden="true">&times;</span>
+                    </button>
+                  </span>
+                );
+              })}
+          </div>
+        </div>
+      </>
+    );
+  }
+}

package/src/pipeline/stages/deployService/cloudFoundryDeployServiceStage.module.ts

@@ -0,0 +1,153 @@
+import { safeLoad } from 'js-yaml';
+import { get, upperFirst } from 'lodash';
+
+import type { IPipeline, IStage, IStageOrTriggerValidator, ITrigger, IValidatorConfig } from '@spinnaker/core';
+import { ExecutionDetailsTasks, PipelineConfigValidator, Registry } from '@spinnaker/core';
+
+import { CloudFoundryDeployServiceStageConfig } from './CloudFoundryDeployServiceStageConfig';
+import type { ICloudFoundryServiceManifestSource } from './ICloudFoundryServiceManifestSource';
+import { CloudFoundryServiceExecutionDetails } from '../../../presentation';
+
+interface IServiceFieldValidatorConfig extends IValidatorConfig {
+  manifestSource: string;
+}
+
+const sourceType = (manifest: ICloudFoundryServiceManifestSource, userProvided: boolean) => {
+  if (manifest && manifest.direct) {
+    return userProvided ? 'userProvided' : 'direct';
+  } else {
+    return 'artifact';
+  }
+};
+
+const sourceStruct = (manifest: ICloudFoundryServiceManifestSource) => {
+  return manifest && manifest.direct ? 'direct' : 'artifact';
+};
+
+PipelineConfigValidator.registerValidator(
+  'requiredDeployServiceField',
+  new (class implements IStageOrTriggerValidator {
+    public validate(
+      _pipeline: IPipeline,
+      stage: IStage | ITrigger,
+      validationConfig: IServiceFieldValidatorConfig,
+    ): string {
+      const serviceInput: ICloudFoundryServiceManifestSource = get(stage, 'manifest');
+      if (sourceType(serviceInput, get(stage, 'userProvided')) !== validationConfig.manifestSource) {
+        return null;
+      }
+      const manifestSource: any = get(serviceInput, sourceStruct(serviceInput));
+      const content: any = get(manifestSource, validationConfig.fieldName);
+      const fieldLabel = validationConfig.fieldLabel || upperFirst(validationConfig.fieldName);
+      return content ? null : `<strong>${fieldLabel}</strong> is a required field for the Deploy Service stage.`;
+    }
+  })(),
+);
+
+PipelineConfigValidator.registerValidator(
+  'validDeployServiceParameterJsonOrYaml',
+  new (class implements IStageOrTriggerValidator {
+    private isJson(value: string): boolean {
+      try {
+        JSON.parse(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+
+    private isYaml(value: string): boolean {
+      try {
+        safeLoad(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+
+    public validate(
+      _pipeline: IPipeline,
+      stage: IStage | ITrigger,
+      validationConfig: IServiceFieldValidatorConfig,
+    ): string {
+      const manifest: any = get(stage, 'manifest');
+      if (sourceType(manifest, get(stage, 'userProvided')) !== validationConfig.manifestSource) {
+        return null;
+      }
+      const manifestSource: any = get(manifest, sourceStruct(manifest));
+      const fieldContent: any = get(manifestSource, validationConfig.fieldName);
+
+      if (fieldContent) {
+        if (!this.isJson(fieldContent) && !this.isYaml(fieldContent)) {
+          const fieldLabel = upperFirst(validationConfig.fieldLabel || validationConfig.fieldName);
+          return validationConfig.message || `<strong>${fieldLabel}</strong> should be a valid JSON or YAML string.`;
+        }
+      }
+      return null;
+    }
+  })(),
+);
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryDeployServiceStageConfig,
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  supportsCustomTimeout: true,
+  description: 'Deploys services using Open Service Broker and deploys user-provided services',
+  executionDetailsSections: [CloudFoundryServiceExecutionDetails, ExecutionDetailsTasks],
+  key: 'deployService',
+  label: 'Deploy Service',
+  validators: [
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+    { type: 'requiredField', fieldName: 'region' },
+    {
+      type: 'requiredDeployServiceField',
+      manifestSource: 'direct',
+      fieldName: 'serviceInstanceName',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'requiredDeployServiceField',
+      manifestSource: 'direct',
+      fieldName: 'service',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'requiredDeployServiceField',
+      manifestSource: 'direct',
+      fieldName: 'servicePlan',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'requiredDeployServiceField',
+      manifestSource: 'artifact',
+      fieldName: 'artifactAccount',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'requiredDeployServiceField',
+      manifestSource: 'artifact',
+      fieldName: 'reference',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'requiredDeployServiceField',
+      manifestSource: 'userProvided',
+      fieldName: 'serviceInstanceName',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'validDeployServiceParameterJsonOrYaml',
+      manifestSource: 'direct',
+      fieldName: 'parameters',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+    {
+      type: 'validDeployServiceParameterJsonOrYaml',
+      manifestSource: 'userProvided',
+      fieldName: 'credentials',
+      preventSave: true,
+    } as IServiceFieldValidatorConfig,
+  ],
+});

package/src/pipeline/stages/deployService/cloudfoundryDeployServiceStage.less

@@ -0,0 +1,12 @@
+.cloudfoundry-deploy-service-stage {
+  .btn-add-tag {
+    margin-left: 1.25rem;
+  }
+  .badge {
+    margin-left: 0.2rem;
+    .close {
+      margin-left: 0.25rem;
+      font-size: 100%;
+    }
+  }
+}

package/src/pipeline/stages/destroyAsg/cloudFoundryDestroyAsgStage.module.ts

@@ -0,0 +1,23 @@
+import type { IStage } from '@spinnaker/core';
+import { Registry } from '@spinnaker/core';
+import { CloudFoundryAsgStageConfig } from '../../../presentation';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryAsgStageConfig,
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  key: 'destroyServerGroup',
+  provides: 'destroyServerGroup',
+  validators: [
+    {
+      type: 'cfTargetImpedance',
+      message:
+        'This pipeline will attempt to destroy a server group without deploying a new version into the same cluster.',
+    },
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+});

package/src/pipeline/stages/destroyService/CloudFoundryDestroyServiceStageConfig.tsx

@@ -0,0 +1,46 @@
+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 { CloudFoundryDestroyServiceStageConfigForm } from './CloudFoundryDestroyServiceStageConfigForm';
+
+export function CloudFoundryDestroyServiceStageConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+}: IStageConfigProps) {
+  const stageWithDefaults = React.useMemo(() => {
+    return {
+      credentials: '',
+      serviceInstanceName: '',
+      removeBindings: false,
+      ...cloneDeep(stage),
+    };
+  }, []);
+
+  return (
+    <FormikStageConfig
+      application={application}
+      onChange={updateStage}
+      pipeline={pipeline}
+      stage={stageWithDefaults}
+      validate={validateCloudFoundryDestroyServiceStage}
+      render={(props) => <CloudFoundryDestroyServiceStageConfigForm {...props} />}
+    />
+  );
+}
+
+export function validateCloudFoundryDestroyServiceStage(stage: IStage): FormikErrors<IStage> {
+  const formValidator = new FormValidator(stage);
+
+  formValidator.field('credentials', 'Account').required();
+  formValidator.field('region', 'Region').required();
+  formValidator.field('serviceInstanceName', 'Service Instance Name').required();
+  formValidator.field('application', 'Application').required();
+
+  return formValidator.validateForm();
+}