@spinnaker/cloudfoundry 0.0.0-main-2

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

@@ -0,0 +1,134 @@
+import React from 'react';
+import type { Option } from 'react-select';
+import Select from 'react-select';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { Application, IAccount, IFormikStageConfigInjectedProps, IRegion } from '@spinnaker/core';
+import { AccountService, StageConfigField } from '@spinnaker/core';
+
+export interface ICloudFoundryDestroyServiceStageConfigState {
+  accounts: IAccount[];
+  regions: string[];
+  application: Application;
+}
+
+export class CloudFoundryDestroyServiceStageConfigForm extends React.Component<
+  IFormikStageConfigInjectedProps,
+  ICloudFoundryDestroyServiceStageConfigState
+> {
+  private destroy$ = new Subject();
+
+  constructor(props: IFormikStageConfigInjectedProps, context: any) {
+    super(props, context);
+    this.props.formik.setFieldValue('cloudProvider', 'cloudfoundry');
+    this.state = {
+      accounts: [],
+      regions: [],
+      application: props.application,
+    };
+  }
+
+  public componentDidMount() {
+    const stage = this.props.formik.values;
+    this.props.formik.setFieldValue('application', this.state.application.name);
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((rawAccounts: IAccount[]) => this.setState({ accounts: rawAccounts }));
+    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 accountUpdated = (option: Option<string>) => {
+    const creds = option.value;
+    this.props.formik.setFieldValue('credentials', creds);
+    this.props.formik.setFieldValue('region', '');
+    if (creds) {
+      this.loadRegions(creds);
+    }
+  };
+
+  private regionUpdated = (option: Option<string>) => {
+    this.props.formik.setFieldValue('region', option.value);
+  };
+
+  private serviceInstanceNameUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.formik.setFieldValue('serviceInstanceName', event.target.value);
+  };
+
+  private removeBindingsUpdated = (event: React.ChangeEvent<HTMLInputElement>) => {
+    this.props.formik.setFieldValue('removeBindings', event.target.checked);
+  };
+
+  public render() {
+    const stage = this.props.formik.values;
+    const { accounts, regions } = this.state;
+    const { credentials, region, serviceInstanceName } = stage;
+    return (
+      <div className="form-horizontal">
+        <StageConfigField label="Account">
+          <Select
+            options={
+              accounts &&
+              accounts.map((acc: IAccount) => ({
+                label: acc.name,
+                value: acc.name,
+              }))
+            }
+            clearable={false}
+            value={credentials}
+            onChange={this.accountUpdated}
+          />
+        </StageConfigField>
+        <StageConfigField label="Region">
+          <Select
+            options={
+              regions &&
+              regions.map((r: string) => ({
+                label: r,
+                value: r,
+              }))
+            }
+            clearable={false}
+            value={region}
+            onChange={this.regionUpdated}
+          />
+        </StageConfigField>
+        <StageConfigField label="Service Instance Name">
+          <input
+            type="text"
+            className="form-control"
+            required={true}
+            onChange={this.serviceInstanceNameUpdated}
+            value={serviceInstanceName}
+          />
+        </StageConfigField>
+        <StageConfigField label="Remove Bindings">
+          <input type="checkbox" checked={stage.removeBindings} onChange={this.removeBindingsUpdated} />
+          {stage.removeBindings && (
+            <div>
+              Warning: Prior to destroying, this will attempt to unbind any server groups that are bound to this
+              service. This stage will fail if any server groups don't belong to the spinnaker application.
+            </div>
+          )}
+        </StageConfigField>
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/destroyService/cloudFoundryDestroyServiceStage.module.ts

@@ -0,0 +1,20 @@
+import type { IStage } from '@spinnaker/core';
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import {
+  CloudFoundryDestroyServiceStageConfig,
+  validateCloudFoundryDestroyServiceStage,
+} from './CloudFoundryDestroyServiceStageConfig';
+import { CloudFoundryServiceExecutionDetails } from '../../../presentation';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryDestroyServiceStageConfig,
+  supportsCustomTimeout: true,
+  executionDetailsSections: [CloudFoundryServiceExecutionDetails, ExecutionDetailsTasks],
+  key: 'destroyService',
+  provides: 'destroyService',
+  validateFn: validateCloudFoundryDestroyServiceStage,
+});

package/src/pipeline/stages/disableAsg/cloudFoundryDisableAsgStage.module.ts

@@ -0,0 +1,18 @@
+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: 'disableServerGroup',
+  provides: 'disableServerGroup',
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+});

package/src/pipeline/stages/enableAsg/cloudFoundryEnableAsgStage.module.ts

@@ -0,0 +1,18 @@
+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: 'enableServerGroup',
+  provides: 'enableServerGroup',
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+});

package/src/pipeline/stages/mapLoadBalancers/cloudFoundryMapLoadBalancersStage.module.ts

@@ -0,0 +1,21 @@
+import type { IStage } from '@spinnaker/core';
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+import { CloudFoundryLoadBalancersExecutionDetails, CloudFoundryLoadBalancersStageConfig } from '../../../presentation';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryLoadBalancersStageConfig,
+  description: 'Map a load balancer',
+  executionDetailsSections: [CloudFoundryLoadBalancersExecutionDetails, ExecutionDetailsTasks],
+  key: 'mapLoadBalancers',
+  label: 'Map Load Balancer',
+  validators: [
+    { type: 'requiredField', preventSave: true, fieldName: 'cluster' },
+    { type: 'requiredField', preventSave: true, fieldName: 'credentials', fieldLabel: 'account' },
+    { type: 'requiredField', preventSave: true, fieldName: 'region' },
+    { type: 'requiredField', preventSave: true, fieldName: 'target' },
+    { type: 'cfRequiredRoutesField', preventSave: true, fieldName: 'loadBalancerNames' },
+  ],
+});

package/src/pipeline/stages/resizeAsg/CloudFoundryResizeAsgStageConfig.tsx

@@ -0,0 +1,148 @@
+import React from 'react';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import { AccountService, NgReact, StageConfigField, StageConstants } from '@spinnaker/core';
+import { AccountRegionClusterSelector } from '../../../presentation';
+
+export interface ICloudFoundryResizeAsgStageConfigState {
+  accounts: IAccount[];
+}
+
+export class CloudFoundryResizeAsgStageConfig extends React.Component<
+  IStageConfigProps,
+  ICloudFoundryResizeAsgStageConfigState
+> {
+  private destroy$ = new Subject();
+
+  constructor(props: IStageConfigProps) {
+    super(props);
+    const { stage } = props;
+    let interestingHealthProviderNames;
+    if (
+      stage.isNew &&
+      props.application.attributes.platformHealthOnlyShowOverride &&
+      props.application.attributes.platformHealthOnly
+    ) {
+      interestingHealthProviderNames = ['Cloud Foundry'];
+    }
+    const { capacity } = stage;
+    this.props.updateStageField({
+      action: 'scale_exact',
+      capacity: capacity && capacity.desired ? capacity : { desired: 1, min: 1, max: 1 },
+      cloudProvider: 'cloudfoundry',
+      diskQuota: stage.diskQuota || 1024,
+      interestingHealthProviderNames: interestingHealthProviderNames,
+      memory: stage.memory || 1024,
+    });
+
+    this.state = { accounts: [] };
+  }
+
+  public componentDidMount(): void {
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((accounts) => this.setState({ accounts }));
+    this.props.stageFieldUpdated();
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private instanceCountUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    const instanceCount = parseInt(event.target.value, 10);
+    this.props.updateStageField({
+      capacity: {
+        desired: instanceCount,
+        min: instanceCount,
+        max: instanceCount,
+      },
+    });
+  };
+
+  private memoryUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    this.props.updateStageField({ memory: parseInt(event.target.value, 10) });
+  };
+
+  private diskQuotaUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    this.props.updateStageField({ diskQuota: parseInt(event.target.value, 10) });
+  };
+
+  private targetUpdated = (target: string) => {
+    this.props.updateStageField({ target });
+  };
+
+  private componentUpdated = (stage: any): void => {
+    this.props.updateStageField({
+      credentials: stage.credentials,
+      regions: stage.regions,
+      cluster: stage.cluster,
+    });
+  };
+
+  public render() {
+    const { accounts } = this.state;
+    const { application, pipeline, stage } = this.props;
+    const { capacity, diskQuota, memory, target } = stage;
+    const instanceCount = capacity.desired;
+    const { TargetSelect } = NgReact;
+    return (
+      <div className="cloudfoundry-resize-asg-stage form-horizontal">
+        {!pipeline.strategy && (
+          <AccountRegionClusterSelector
+            accounts={accounts}
+            application={application}
+            cloudProvider={'cloudfoundry'}
+            onComponentUpdate={this.componentUpdated}
+            component={stage}
+          />
+        )}
+        <StageConfigField label="Target">
+          <TargetSelect model={{ target }} options={StageConstants.TARGET_LIST} onChange={this.targetUpdated} />
+        </StageConfigField>
+        <div className="form-group">
+          <span className="col-md-3 sm-label-right" />
+          <div className="col-md-9">
+            <div className="col-md-3 sm-label-left">Instances</div>
+            <div className="col-md-3 sm-label-left">Mem (MB)</div>
+            <div className="col-md-3 sm-label-left">Disk (MB)</div>
+          </div>
+          <StageConfigField label="Match capacity">
+            <div className="col-md-3">
+              <input
+                type="number"
+                key="instanceCount"
+                onChange={this.instanceCountUpdated}
+                value={instanceCount}
+                className="form-control input-sm"
+              />
+            </div>
+            <div className="col-md-3">
+              <input
+                type="number"
+                key="memory"
+                onChange={this.memoryUpdated}
+                value={memory}
+                className="form-control input-sm"
+              />
+            </div>
+            <div className="col-md-3">
+              <input
+                type="number"
+                key="diskQuota"
+                onChange={this.diskQuotaUpdated}
+                value={diskQuota}
+                className="form-control input-sm"
+              />
+            </div>
+            <div className="col-md-9 col-md-offset-3">
+              <em className="subinput-note">Scaled capacity will match the numbers entered</em>
+            </div>
+          </StageConfigField>
+        </div>
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/resizeAsg/cloudFoundryResizeAsgStage.module.ts

@@ -0,0 +1,52 @@
+import type { IStage } from '@spinnaker/core';
+import { Registry } from '@spinnaker/core';
+
+import { CloudFoundryResizeAsgStageConfig } from './CloudFoundryResizeAsgStageConfig';
+import type { IInstanceFieldSizeValidationConfig } from '../../config/validation/instanceSize.validator';
+
+const diskValidator: IInstanceFieldSizeValidationConfig = {
+  type: 'cfInstanceSizeField',
+  fieldName: 'diskQuota',
+  fieldLabel: 'Disk Mb',
+  min: 256,
+  preventSave: true,
+};
+
+const instanceCountValidator: IInstanceFieldSizeValidationConfig = {
+  type: 'cfInstanceSizeField',
+  fieldName: 'capacity.desired',
+  fieldLabel: 'Instances',
+  min: 0,
+  preventSave: true,
+};
+
+const memoryValidator: IInstanceFieldSizeValidationConfig = {
+  type: 'cfInstanceSizeField',
+  fieldName: 'memory',
+  fieldLabel: 'Mem Mb',
+  min: 256,
+  preventSave: true,
+};
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryResizeAsgStageConfig,
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  key: 'resizeServerGroup',
+  provides: 'resizeServerGroup',
+  validators: [
+    {
+      type: 'cfTargetImpedance',
+      message:
+        'This pipeline will attempt to resize 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' },
+    instanceCountValidator,
+    memoryValidator,
+    diskValidator,
+  ],
+});

package/src/pipeline/stages/rollbackCluster/CloudFoundryRollbackClusterStageConfig.tsx

@@ -0,0 +1,90 @@
+import React from 'react';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { IAccount, IPipeline, IStageConfigProps } from '@spinnaker/core';
+import { AccountService, StageConfigField } from '@spinnaker/core';
+import { AccountRegionClusterSelector } from '../../../presentation';
+
+export interface ICloudFoundryRollbackClusterStageProps extends IStageConfigProps {
+  pipeline: IPipeline;
+}
+
+export interface ICloudFoundryRollbackClusterStageConfigState {
+  accounts: IAccount[];
+}
+
+export class CloudFoundryRollbackClusterStageConfig extends React.Component<
+  ICloudFoundryRollbackClusterStageProps,
+  ICloudFoundryRollbackClusterStageConfigState
+> {
+  private destroy$ = new Subject();
+
+  constructor(props: ICloudFoundryRollbackClusterStageProps) {
+    super(props);
+
+    this.props.updateStageField({
+      cloudProvider: 'cloudfoundry',
+      regions: this.props.stage.regions || [],
+      targetHealthyRollbackPercentage: 100,
+    });
+
+    this.state = { accounts: [] };
+  }
+
+  public componentDidMount(): void {
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((accounts) => this.setState({ accounts }));
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private waitTimeBetweenRegionsUpdated = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    const time = parseInt(event.target.value || '0', 10);
+    this.props.updateStageField({ waitTimeBetweenRegions: time });
+  };
+
+  private componentUpdate = (stage: any): void => {
+    this.props.updateStageField({
+      credentials: stage.credentials,
+      regions: stage.regions,
+      cluster: stage.cluster,
+      moniker: stage.moniker,
+    });
+  };
+
+  public render() {
+    const { application, pipeline, stage } = this.props;
+    const { waitTimeBetweenRegions } = stage;
+    const { accounts } = this.state;
+    return (
+      <div className="form-horizontal">
+        {!pipeline.strategy && (
+          <AccountRegionClusterSelector
+            accounts={accounts}
+            application={application}
+            cloudProvider={'cloudfoundry'}
+            onComponentUpdate={this.componentUpdate}
+            component={stage}
+          />
+        )}
+
+        {stage.regions.length > 1 && (
+          <StageConfigField label="Wait">
+            <input
+              type="number"
+              min="0"
+              value={waitTimeBetweenRegions}
+              onChange={this.waitTimeBetweenRegionsUpdated}
+              className="form-control input-sm inline-number"
+            />
+            &nbsp;seconds between regional rollbacks.
+          </StageConfigField>
+        )}
+      </div>
+    );
+  }
+}

package/src/pipeline/stages/rollbackCluster/cloudFoundryRollbackClusterStage.module.ts

@@ -0,0 +1,19 @@
+import type { IStage } from '@spinnaker/core';
+import { Registry } from '@spinnaker/core';
+
+import { CloudFoundryRollbackClusterStageConfig } from './CloudFoundryRollbackClusterStageConfig';
+
+Registry.pipeline.registerStage({
+  accountExtractor: (stage: IStage) => [stage.context.credentials],
+  configAccountExtractor: (stage: IStage) => [stage.credentials],
+  provides: 'rollbackCluster',
+  key: 'rollbackCluster',
+  cloudProvider: 'cloudfoundry',
+  component: CloudFoundryRollbackClusterStageConfig,
+  controller: 'cfRollbackClusterStageCtrl',
+  validators: [
+    { type: 'requiredField', preventSave: true, fieldName: 'cluster' },
+    { type: 'requiredField', preventSave: true, fieldName: 'regions' },
+    { type: 'requiredField', preventSave: true, fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+});

package/src/pipeline/stages/runJob/CloudFoundryRunJobStageConfig.tsx

@@ -0,0 +1,100 @@
+import React from 'react';
+import { from as observableFrom, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import { AccountService, NgReact, SpelText, StageConfigField, StageConstants, TextInput } from '@spinnaker/core';
+import { AccountRegionClusterSelector } from '../../../presentation';
+
+export interface ICloudFoundryRunTaskStageConfigState {
+  accounts: IAccount[];
+  region: string;
+}
+
+export class CloudFoundryRunJobStageConfig extends React.Component<
+  IStageConfigProps,
+  ICloudFoundryRunTaskStageConfigState
+> {
+  private destroy$ = new Subject();
+
+  constructor(props: IStageConfigProps) {
+    super(props);
+    props.stage.cloudProvider = 'cloudfoundry';
+    this.state = {
+      accounts: [],
+      region: '',
+    };
+  }
+
+  public componentDidMount(): void {
+    observableFrom(AccountService.listAccounts('cloudfoundry'))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((accounts) => this.setState({ accounts }));
+    this.props.stageFieldUpdated();
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+  }
+
+  private componentUpdated = (stage: any): void => {
+    this.props.updateStageField({
+      credentials: stage.credentials,
+      region: stage.region,
+      cluster: stage.cluster,
+    });
+  };
+
+  public render() {
+    const { application, stage } = this.props;
+    const { target, jobName, command, logsUrl } = stage;
+    const { accounts } = this.state;
+    const { TargetSelect } = NgReact;
+
+    return (
+      <div className="cloudfoundry-resize-asg-stage form-horizontal">
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          cloudProvider={'cloudfoundry'}
+          onComponentUpdate={this.componentUpdated}
+          component={stage}
+          isSingleRegion={true}
+        />
+        <StageConfigField label="Target">
+          <TargetSelect
+            model={{ target }}
+            options={StageConstants.TARGET_LIST}
+            onChange={(t) => this.props.updateStageField({ target: t })}
+          />
+        </StageConfigField>
+        <StageConfigField label="Job Name" helpKey={'cf.runJob.jobName'}>
+          <TextInput
+            type="text"
+            className="form-control"
+            onChange={(e) => this.props.updateStageField({ jobName: e.target.value })}
+            value={jobName}
+            maxLength={238}
+          />
+        </StageConfigField>
+        <StageConfigField label="Command">
+          <TextInput
+            type="text"
+            className="form-control"
+            onChange={(e) => this.props.updateStageField({ command: e.target.value })}
+            value={command}
+          />
+        </StageConfigField>
+        <StageConfigField label="Logs URL" helpKey={'cf.runJob.logsUrl'}>
+          <SpelText
+            placeholder=""
+            onChange={(value) => this.props.updateStageField({ logsUrl: value })}
+            value={logsUrl}
+            pipeline={this.props.pipeline}
+            docLink={false}
+          />
+        </StageConfigField>
+      </div>
+    );
+  }
+}