@spinnaker/cloudfoundry 0.0.0-main-2

package/src/deploymentStrategy/CloudFoundryDeploymentStrategySelector.tsx

@@ -0,0 +1,175 @@
+import { defaultsDeep, unset } from 'lodash';
+import React from 'react';
+import type { Option } from 'react-select';
+import Select from 'react-select';
+
+import type {
+  IDeploymentStrategy,
+  IDeploymentStrategyAdditionalFieldsProps,
+  IServerGroupCommand,
+} from '@spinnaker/core';
+import { CoreRedBlackAdditionalFields, HelpField, Markdown } from '@spinnaker/core';
+
+import type { IRedBlackCommand } from './strategies/redblack/redblack.strategy';
+import type { IRollingRedBlackCommand } from './strategies/rollingredblack/AdditionalFields';
+import { AdditionalFields as AdditionalRollingRedBlackFields } from './strategies/rollingredblack/AdditionalFields';
+
+export interface ICloudFoundryDeploymentStrategySelectorProps {
+  command: IServerGroupCommand;
+  onFieldChange: (key: string, value: any) => void;
+  onStrategyChange: (command: IServerGroupCommand, strategy: IDeploymentStrategy) => void;
+}
+
+export interface ICloudFoundryDeploymentStrategySelectorState {
+  strategies: IDeploymentStrategy[];
+  currentStrategy: string;
+  AdditionalFieldsComponent: React.ComponentType<IDeploymentStrategyAdditionalFieldsProps>;
+}
+
+export class CloudFoundryDeploymentStrategySelector extends React.Component<
+  ICloudFoundryDeploymentStrategySelectorProps,
+  ICloudFoundryDeploymentStrategySelectorState
+> {
+  public state: ICloudFoundryDeploymentStrategySelectorState = {
+    strategies: [
+      {
+        label: 'None',
+        description: 'Creates the next server group with no impact on existing server groups',
+        key: '',
+      },
+      {
+        label: 'Highlander',
+        description:
+          'Destroys <i>all</i> previous server groups in the cluster as soon as new server group passes health checks',
+        key: 'highlander',
+      },
+      {
+        label: 'Red/Black',
+        description:
+          'Disables <i>all</i> previous server groups in the cluster as soon as new server group passes health checks',
+        key: 'redblack',
+        additionalFields: ['maxRemainingAsgs'],
+        AdditionalFieldsComponent: CoreRedBlackAdditionalFields,
+        initializationMethod: (command: IRedBlackCommand) => {
+          defaultsDeep(command, {
+            rollback: {
+              onFailure: false,
+            },
+            maxRemainingAsgs: 2,
+            delayBeforeDisableSec: 0,
+            delayBeforeScaleDownSec: 0,
+            scaleDown: false,
+          });
+        },
+      },
+      {
+        label: 'Rolling Red/Black',
+        description:
+          'Gradually replaces <i>all</i> previous server group instances in the cluster as soon as new server group instances pass health checks',
+        key: 'cfrollingredblack',
+        additionalFields: ['targetPercentages'],
+        AdditionalFieldsComponent: AdditionalRollingRedBlackFields,
+        initializationMethod: (command: IRollingRedBlackCommand) => {
+          defaultsDeep(command, {
+            rollback: {
+              onFailure: false,
+            },
+            targetPercentages: command.targetPercentages ? command.targetPercentages : [50, 100], // defaultsDeep does not work with arrays
+            delayBeforeDisableSec: 0,
+            delayBeforeScaleDownSec: 0,
+            maxRemainingAsgs: 2,
+            scaleDown: false,
+          });
+        },
+      },
+    ],
+    currentStrategy: null,
+    AdditionalFieldsComponent: undefined,
+  };
+
+  public selectStrategy(strategy: string): void {
+    const { command, onStrategyChange } = this.props;
+    const oldStrategy = this.state.strategies.find((s) => s.key === this.state.currentStrategy);
+    const newStrategy = this.state.strategies.find((s) => s.key === strategy);
+
+    if (oldStrategy && oldStrategy.additionalFields) {
+      oldStrategy.additionalFields.forEach((field) => {
+        if (!newStrategy || !newStrategy.additionalFields || !newStrategy.additionalFields.includes(field)) {
+          unset(command, field);
+        }
+      });
+    }
+
+    let AdditionalFieldsComponent;
+    if (newStrategy) {
+      AdditionalFieldsComponent = newStrategy.AdditionalFieldsComponent;
+      if (newStrategy.initializationMethod) {
+        newStrategy.initializationMethod(command);
+      }
+    }
+    command.strategy = strategy;
+    if (onStrategyChange && newStrategy) {
+      onStrategyChange(command, newStrategy);
+    }
+    this.setState({ currentStrategy: strategy, AdditionalFieldsComponent });
+  }
+
+  public strategyChanged = (option: Option<IDeploymentStrategy>) => {
+    this.selectStrategy(option.key);
+  };
+
+  public componentDidMount() {
+    this.selectStrategy(this.props.command.strategy);
+  }
+
+  public render() {
+    const { command, onFieldChange } = this.props;
+    const { AdditionalFieldsComponent, currentStrategy, strategies } = this.state;
+    const hasAdditionalFields = Boolean(AdditionalFieldsComponent);
+    if (strategies && strategies.length) {
+      return (
+        <div>
+          <div className="StandardFieldLayout flex-container-h baseline margin-between-lg">
+            <div className={`sm-label-right`} style={{ paddingLeft: '13px' }}>
+              Strategy &nbsp;
+              <HelpField id="core.serverGroup.strategy" />
+            </div>
+            <div className="flex-grow">
+              <Select
+                clearable={false}
+                required={true}
+                options={strategies}
+                placeholder="None"
+                valueKey="key"
+                value={currentStrategy}
+                optionRenderer={this.strategyOptionRenderer}
+                valueRenderer={(o) => <>{o.label}</>}
+                onChange={this.strategyChanged}
+              />
+            </div>
+          </div>
+          {hasAdditionalFields && (
+            <div className="form-group col-md-9 col-md-offset-3" style={{ marginTop: '5px', float: 'right' }}>
+              <AdditionalFieldsComponent command={command} onChange={onFieldChange} />
+            </div>
+          )}
+        </div>
+      );
+    }
+
+    return null;
+  }
+
+  private strategyOptionRenderer = (option: IDeploymentStrategy) => {
+    return (
+      <div className="body-regular">
+        <strong>
+          <Markdown tag="span" message={option.label} />
+        </strong>
+        <div>
+          <Markdown tag="span" message={option.description} />
+        </div>
+      </div>
+    );
+  };
+}

package/src/deploymentStrategy/strategies/redblack/redblack.strategy.ts

@@ -0,0 +1,11 @@
+import type { IServerGroupCommand } from '@spinnaker/core';
+
+export interface IRedBlackCommand extends IServerGroupCommand {
+  maxRemainingAsgs: number;
+  delayBeforeDisableSec: number;
+  delayBeforeScaleDownSec: number;
+  rollback: {
+    onFailure: boolean;
+  };
+  scaleDown: boolean;
+}

package/src/deploymentStrategy/strategies/rollingredblack/AdditionalFields.tsx

@@ -0,0 +1,161 @@
+import { set } from 'lodash';
+import React from 'react';
+
+import type { IDeploymentStrategyAdditionalFieldsProps, IServerGroupCommand } from '@spinnaker/core';
+import { HelpField } from '@spinnaker/core';
+
+export interface IRollingRedBlackCommand extends IServerGroupCommand {
+  targetPercentages: number[];
+  delayBeforeDisableSec: number;
+  delayBeforeScaleDownSec: number;
+  maxRemainingAsgs: number;
+  rollback: {
+    onFailure: boolean;
+  };
+  scaleDown: boolean;
+}
+
+export interface IRollingRedBlackStrategyAdditionalFieldsProps extends IDeploymentStrategyAdditionalFieldsProps {
+  command: IRollingRedBlackCommand;
+}
+
+export class AdditionalFields extends React.Component<IRollingRedBlackStrategyAdditionalFieldsProps> {
+  private handlePercentChange = (key: string, value: any, index: number) => {
+    const percentages = this.props.command.targetPercentages;
+    percentages[index] = value;
+    set(this.props.command, key, percentages);
+    this.forceUpdate();
+  };
+
+  private onDelete = (index: number) => {
+    const percentages = this.props.command.targetPercentages;
+    percentages.splice(index, 1);
+    set(this.props.command, 'targetPercentages', percentages);
+    this.forceUpdate();
+  };
+
+  private addPercent = () => {
+    const percentages = this.props.command.targetPercentages;
+    percentages.push(100);
+    set(this.props.command, 'targetPercentages', percentages);
+    this.forceUpdate();
+  };
+
+  private handleChange = (key: string, value: any) => {
+    set(this.props.command, key, value);
+    this.forceUpdate();
+  };
+
+  public render() {
+    const { command } = this.props;
+    return (
+      <div className="form-group">
+        <div className="col-md-12">
+          <div className="col-md-12 checkbox">
+            <label>
+              <input
+                type="checkbox"
+                checked={command.rollback.onFailure}
+                onChange={(e) => this.handleChange('rollback.onFailure', e.target.checked)}
+              />
+              Rollback to previous server group if deployment fails <HelpField id="strategy.rollingRedBlack.rollback" />
+            </label>
+          </div>
+          <div className="col-md-12 form-inline sp-margin-m-bottom sp-margin-m-top">
+            <label>
+              Wait Before Scale Down &nbsp;
+              <HelpField content="Time to wait before scaling down source server group" />
+            </label>
+            <div>
+              <input
+                className="form-control input-sm"
+                style={{ width: '60px' }}
+                min="0"
+                type="number"
+                value={command.delayBeforeDisableSec}
+                onChange={(e) => this.handleChange('delayBeforeDisableSec', e.target.value)}
+                placeholder="0"
+              />
+              &nbsp; seconds
+            </div>
+          </div>
+          <div className="col-md-12 form-inline sp-margin-m-bottom">
+            <label>
+              Maximum number of server groups to leave &nbsp;
+              <HelpField id="strategy.redblack.maxRemainingAsgs" />
+            </label>
+            <div>
+              <input
+                className="form-control input-sm"
+                style={{ width: '60px' }}
+                min="2"
+                type="number"
+                value={command.maxRemainingAsgs}
+                onChange={(e) => this.handleChange('maxRemainingAsgs', e.target.value)}
+              />
+              &nbsp; server groups
+            </div>
+          </div>
+          <div className="col-md-12 form-inline sp-margin-m-bottom">
+            <label>
+              Wait Before Cluster Scale Down &nbsp;
+              <HelpField content="Time to wait before scaling down the cluster after deployment" />
+            </label>
+            <div>
+              <input
+                className="form-control input-sm"
+                style={{ width: '60px' }}
+                min="0"
+                type="number"
+                value={command.delayBeforeScaleDownSec}
+                onChange={(e) => this.handleChange('delayBeforeScaleDownSec', e.target.value)}
+                placeholder="0"
+              />
+              &nbsp; seconds
+            </div>
+          </div>
+          <label>
+            Scale by percentages &nbsp;
+            <HelpField content="Steps to get to full capacity in percent" />
+          </label>
+          <table className="table table-condensed packed metadata">
+            <tbody>
+              {command.targetPercentages.map((percentage: number, index: number) => {
+                return (
+                  <tr key={index}>
+                    <td>
+                      <div className="sp-margin-m-bottom">
+                        <input
+                          className="form-control"
+                          min="0"
+                          type="number"
+                          value={percentage}
+                          onChange={(e) => this.handlePercentChange('targetPercentages', e.target.value, index)}
+                          placeholder="100"
+                        />
+                      </div>
+                    </td>
+                    <td>
+                      <a className="btn btn-link sm-label" onClick={() => this.onDelete(index)}>
+                        <span className="glyphicon glyphicon-trash" />
+                      </a>
+                    </td>
+                  </tr>
+                );
+              })}
+            </tbody>
+            <tfoot>
+              <tr>
+                <td colSpan={2}>
+                  <button type="button" className="add-new col-md-12" onClick={() => this.addPercent()}>
+                    <span className="glyphicon glyphicon-plus-sign" /> Add percentage
+                  </button>
+                </td>
+              </tr>
+            </tfoot>
+          </table>
+        </div>
+      </div>
+    );
+  }
+}

package/src/domain/ICloudFoundryAccount.ts

@@ -0,0 +1,9 @@
+import type { IAccountDetails } from '@spinnaker/core';
+
+import type { ICloudFoundryDomain } from './ICloudFoundryLoadBalancer';
+import type { ICloudFoundrySpace } from './ICloudFoundrySpace';
+
+export interface ICloudFoundryAccount extends IAccountDetails {
+  domains?: ICloudFoundryDomain[];
+  spaces?: ICloudFoundrySpace[];
+}

package/src/domain/ICloudFoundryApplication.ts

@@ -0,0 +1,5 @@
+import type { Application } from '@spinnaker/core';
+
+export interface ICloudFoundryApplication extends Application {
+  startApplication: boolean;
+}

package/src/domain/ICloudFoundryCluster.ts

@@ -0,0 +1,6 @@
+import type { ICloudFoundryServerGroup } from './ICloudFoundryServerGroup';
+
+export interface ICloudFoundryCluster {
+  name: string;
+  serverGroups: ICloudFoundryServerGroup[];
+}

package/src/domain/ICloudFoundryDroplet.ts

@@ -0,0 +1,22 @@
+import type { ICloudFoundrySpace } from './ICloudFoundrySpace';
+
+export interface ICloudFoundryDroplet {
+  id: string;
+  name: string;
+  space: ICloudFoundrySpace;
+  stack: string;
+  buildpacks: ICloudFoundryBuildpack[];
+  sourcePackage?: ICloudFoundryPackage;
+}
+
+export interface ICloudFoundryBuildpack {
+  name: string;
+  detectOutput: string;
+  version: string;
+  buildpackName: string;
+}
+
+export interface ICloudFoundryPackage {
+  checksum: string;
+  downloadUrl: string;
+}

package/src/domain/ICloudFoundryInstance.ts

@@ -0,0 +1,5 @@
+import type { IInstance } from '@spinnaker/core';
+
+export interface ICloudFoundryInstance extends IInstance {
+  details?: string;
+}

package/src/domain/ICloudFoundryLoadBalancer.ts

@@ -0,0 +1,29 @@
+import type { ILoadBalancer, ILoadBalancerUpsertCommand } from '@spinnaker/core';
+
+import type { ICloudFoundryServerGroup } from './ICloudFoundryServerGroup';
+import type { ICloudFoundryOrganization, ICloudFoundrySpace } from './ICloudFoundrySpace';
+
+export interface ICloudFoundryDomain {
+  id: string;
+  name: string;
+  organization: ICloudFoundryOrganization;
+}
+
+export interface ICloudFoundryLoadBalancer extends ILoadBalancer {
+  id: string;
+  host?: string;
+  path?: string;
+  port?: string;
+  space: ICloudFoundrySpace;
+  serverGroups: ICloudFoundryServerGroup[];
+  domain?: ICloudFoundryDomain;
+}
+
+export interface ICloudFoundryLoadBalancerUpsertCommand extends ILoadBalancerUpsertCommand {
+  id?: string;
+  host: string;
+  path?: string;
+  port?: string;
+  serverGroups?: ICloudFoundryServerGroup[];
+  domain: string;
+}

package/src/domain/ICloudFoundryServerGroup.ts

@@ -0,0 +1,47 @@
+import type { IServerGroup } from '@spinnaker/core';
+
+import type { ICloudFoundryDroplet } from './ICloudFoundryDroplet';
+import type { ICloudFoundryInstance } from './ICloudFoundryInstance';
+import type { ICloudFoundrySpace } from './ICloudFoundrySpace';
+
+export interface ICloudFoundryServerGroup extends IServerGroup {
+  appsManagerUri?: string;
+  diskQuota: number;
+  healthCheckType: string;
+  healthCheckHttpEndpoint: string;
+  state: 'STARTED' | 'STOPPED';
+  instances: ICloudFoundryInstance[];
+  metricsUri?: string;
+  memory: number;
+  space: ICloudFoundrySpace;
+  droplet?: ICloudFoundryDroplet;
+  serviceInstances: ICloudFoundryServiceInstance[];
+  env: ICloudFoundryEnvVar[];
+  ciBuild: ICloudFoundryBuildInfo;
+  appArtifact: ICloudFoundryArtifactInfo;
+  pipelineId: string;
+}
+
+export interface ICloudFoundryServiceInstance {
+  name: string;
+  plan: string;
+  service: string;
+  tags?: string[];
+}
+
+export interface ICloudFoundryEnvVar {
+  key: string;
+  value: string;
+}
+
+export interface ICloudFoundryBuildInfo {
+  jobName: string;
+  jobNumber: string;
+  jobUrl: string;
+}
+
+export interface ICloudFoundryArtifactInfo {
+  name: string;
+  version: string;
+  url: string;
+}

package/src/domain/ICloudFoundrySpace.ts

@@ -0,0 +1,10 @@
+export interface ICloudFoundrySpace {
+  id?: string;
+  name: string;
+  organization: ICloudFoundryOrganization;
+}
+
+export interface ICloudFoundryOrganization {
+  id?: string;
+  name: string;
+}

package/src/domain/index.ts

@@ -0,0 +1,8 @@
+export * from './ICloudFoundryAccount';
+export * from './ICloudFoundryApplication';
+export * from './ICloudFoundryDroplet';
+export * from './ICloudFoundryInstance';
+export * from './ICloudFoundrySpace';
+export * from './ICloudFoundryLoadBalancer';
+export * from './ICloudFoundryServerGroup';
+export * from './ICloudFoundryCluster';

package/src/help/cloudfoundry.help.ts

@@ -0,0 +1,31 @@
+import { HelpContentsRegistry } from '@spinnaker/core';
+
+const helpContents: { [key: string]: string } = {
+  'cf.service.deploy.timeout':
+    '(Optional) <b>Override Deploy Timeout</b> is the maximum amount of time allowed for service deployment before Spinnaker reports a timeout error (default: 450 seconds). If a timeout error is reported by Spinnaker, the request may still be processed and a service may still be created.',
+  'cf.service.destroy.timeout':
+    '(Optional) <b>Override Destroy Timeout</b> is the maximum amount of time allowed for service destruction before Spinnaker reports a timeout error (default: 450 seconds). If a timeout error is reported by Spinnaker, the request may still be processed and the service may be deleted.',
+  'cf.serverGroup.stack':
+    '(Optional) <b>Stack</b> is one of the core naming components of a cluster, used to create vertical stacks of dependent services for integration testing.',
+  'cf.serverGroup.detail':
+    '(Optional) <b>Detail</b> is a string of free-form alphanumeric characters and hyphens to describe any other variables.',
+  'cf.serverGroup.startApplication':
+    '<b>Start on creation</b> is a boolean value that determines if the server group is started upon creation. Default value is <code>true</code>.',
+  'cf.serverGroup.requiredRoutes':
+    '<b>Route</b> is a URI in the form of <code>some.host.some.domain[:9999][/some/path]</code> (port and path are optional). The domain has to be a valid domain in the CloudFoundry Org (Region) that this server group runs in.',
+  'cf.serverGroup.routes':
+    '(Optional) <b>Route</b> is a URI in the form of <code>some.host.some.domain[:9999][/some/path]</code> (port and path are optional). The domain has to be a valid domain in the CloudFoundry Org (Region) that this server group runs in.',
+  'cf.artifact.package': `<p>This option allows you to create a new server group from an existing Droplet. You can use this to relocate an existing Cloud Foundry application from one space to another or to launch a clone of an application with different root filesystem or resource settings.</p>`,
+  'cf.artifact.trigger.account': `<p>Specify an artifact account if the trigger source produces an artifact that requires authentication credentials to retrieve. Otherwise, leave blank.</p>`,
+  'cf.runJob.logsUrl':
+    '<p>(Optional) A templated URL to an external logging system. The URL is used in the pipeline execution stage task details.</p>' +
+    '<p><a href="http://spinnaker.github.io/guides/user/pipeline-expressions" target="_blank">Pipeline expressions</a> can be used to interpolate values from the stage context, for example:' +
+    '<ul>' +
+    '<li><code>${appGuid}</code> the selected cluster CF app GUID.</li>' +
+    '<li><code>${name}</code> the task name.</li>' +
+    '</ul>' +
+    '</p>',
+  'cf.runJob.jobName': '(Optional) If left empty, a random string will be generated.',
+};
+
+Object.keys(helpContents).forEach((key) => HelpContentsRegistry.register(key, helpContents[key]));

package/src/image/image.reader.cf.ts

@@ -0,0 +1,17 @@
+import { REST } from '@spinnaker/core';
+import type { ICloudFoundryCluster } from '../domain';
+
+export class CloudFoundryImageReader {
+  public static findImages(account: string): PromiseLike<ICloudFoundryCluster[]> {
+    return REST('/images/find')
+      .query({
+        account,
+        provider: 'cloudfoundry',
+      })
+      .get()
+      .then(function (results: any) {
+        return results;
+      })
+      .catch((): any[] => []);
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './cf.module';
+export * from './cf.settings';
+
+export * from './domain/index';
+export * from './loadBalancer/index';
+export * from './presentation/index';
+export * from './serverGroup/index';

package/src/instance/details/CloudFoundryInstanceActions.tsx

@@ -0,0 +1,59 @@
+import { cloneDeep } from 'lodash';
+import React from 'react';
+import { Dropdown } from 'react-bootstrap';
+
+import type { Application } from '@spinnaker/core';
+import { ConfirmationModalService, InstanceWriter, ReactInjector } from '@spinnaker/core';
+import type { ICloudFoundryInstance } from '../../domain';
+
+export interface ICloudFoundryInstanceActionsProps {
+  application: Application;
+  instance: ICloudFoundryInstance;
+}
+
+export class CloudFoundryInstanceActions extends React.Component<ICloudFoundryInstanceActionsProps> {
+  private terminateInstance = () => {
+    const { application, instance } = this.props;
+    const instanceClone = cloneDeep(instance) as any;
+    instanceClone.placement = {};
+    instanceClone.id = instance.name;
+    const taskMonitor = {
+      application: application,
+      title: 'Terminating ' + instance.name,
+      onTaskComplete() {
+        if (ReactInjector.$state.includes('**.serverGroup', { instanceId: instance.name })) {
+          ReactInjector.$state.go('^');
+        }
+      },
+    };
+
+    const submitMethod = () => {
+      return InstanceWriter.terminateInstance(instance, application, { cloudProvider: 'cloudfoundry' });
+    };
+
+    ConfirmationModalService.confirm({
+      header: 'Really terminate ' + instance.name + '?',
+      buttonText: 'Terminate',
+      account: instance.account,
+      taskMonitorConfig: taskMonitor,
+      submitMethod,
+    });
+  };
+
+  public render(): JSX.Element {
+    return (
+      <div className="actions">
+        <Dropdown className="dropdown" id="instance-actions-dropdown">
+          <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">Instance Actions</Dropdown.Toggle>
+          <Dropdown.Menu className="dropdown-menu">
+            <li>
+              <a className="clickable" onClick={this.terminateInstance}>
+                Terminate
+              </a>
+            </li>
+          </Dropdown.Menu>
+        </Dropdown>
+      </div>
+    );
+  }
+}