@spinnaker/kubernetes 0.0.0-main-2

package/src/manifest/status/condition.component.ts

@@ -0,0 +1,12 @@
+import { module } from 'angular';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { ManifestCondition } from './ManifestCondition';
+
+export const KUBERNETES_MANIFEST_CONDITION = 'spinnaker.kubernetes.v2.manifest.condition.component';
+module(KUBERNETES_MANIFEST_CONDITION, []).component(
+  'kubernetesManifestCondition',
+  react2angular(withErrorBoundary(ManifestCondition, 'kubernetesManifestCondition'), ['condition']),
+);

package/src/manifest/status/status.component.ts

@@ -0,0 +1,36 @@
+import type { IComponentOptions, IController } from 'angular';
+import { module } from 'angular';
+
+import type { IManifestStatus } from '@spinnaker/core';
+
+class KubernetesManifestStatusCtrl implements IController {
+  public status: IManifestStatus;
+}
+
+const kubernetesManifestStatusComponent: IComponentOptions = {
+  bindings: { status: '<' },
+  controller: KubernetesManifestStatusCtrl,
+  controllerAs: 'ctrl',
+  template: `
+    <div ng-if="!ctrl.status" class="horizontal middle center spinner-section">
+      <loading-spinner size="'small'"></loading-spinner>
+    </div>
+    <div ng-if="ctrl.status">
+      <div class="band band-warning" ng-if="!ctrl.status.available.state"
+           uib-tooltip="{{ctrl.status.available.message}}">
+        Not Fully Available
+      </div>
+      <div class="band band-active" ng-if="!ctrl.status.stable.state"
+           uib-tooltip="{{ctrl.status.stable.message}}">
+        Transitioning
+      </div>
+      <div class="band band-info" ng-if="ctrl.status.paused.state"
+           uib-tooltip="{{ctrl.status.paused.message}}">
+        Rollout Paused
+      </div>
+    </div>
+  `,
+};
+
+export const KUBERNETES_MANIFEST_STATUS = 'spinnaker.kubernetes.v2.kubernetes.manifest.status.component';
+module(KUBERNETES_MANIFEST_STATUS, []).component('kubernetesManifestStatus', kubernetesManifestStatusComponent);

package/src/manifest/traffic/ManifestTrafficService.spec.ts

@@ -0,0 +1,30 @@
+import { ManifestTrafficService } from '../../manifest/traffic/ManifestTrafficService';
+
+describe('Service: ManifestTrafficService', () => {
+  it('will not disable an already disabled server group', () => {
+    const canDisable = ManifestTrafficService.canDisableServerGroup({
+      disabled: true,
+      serverGroupManagers: [],
+      loadBalancers: ['service my-service'],
+    } as any);
+    expect(canDisable).toEqual(false);
+  });
+
+  it('will not disable a server group without load balancers', () => {
+    const canDisable = ManifestTrafficService.canDisableServerGroup({
+      disabled: false,
+      serverGroupManagers: [],
+      loadBalancers: [],
+    } as any);
+    expect(canDisable).toEqual(false);
+  });
+
+  it('will not disable a managed server group', () => {
+    const canDisable = ManifestTrafficService.canDisableServerGroup({
+      disabled: false,
+      serverGroupManagers: ['deployment my-deployment'],
+      loadBalancers: ['service my-service'],
+    } as any);
+    expect(canDisable).toEqual(false);
+  });
+});

package/src/manifest/traffic/ManifestTrafficService.ts

@@ -0,0 +1,67 @@
+import type { Application, IManifest, ITask } from '@spinnaker/core';
+import { TaskExecutor } from '@spinnaker/core';
+
+import type { IKubernetesServerGroup } from '../../interfaces';
+
+export class ManifestTrafficService {
+  public static readonly ENABLE_MANIFEST_OPERATION = 'enableManifest';
+  public static readonly DISABLE_MANIFEST_OPERATION = 'disableManifest';
+
+  public static enable = (manifest: IManifest, application: Application, reason?: string): PromiseLike<ITask> => {
+    return TaskExecutor.executeTask({
+      job: [
+        {
+          account: manifest.account,
+          cloudProvider: 'kubernetes',
+          location: manifest.location,
+          manifestName: manifest.name,
+          type: ManifestTrafficService.ENABLE_MANIFEST_OPERATION,
+          reason,
+        },
+      ],
+      application,
+      description: `Enable Manifest: ${manifest.name}`,
+    });
+  };
+
+  public static disable = (manifest: IManifest, application: Application, reason?: string): PromiseLike<ITask> => {
+    return TaskExecutor.executeTask({
+      job: [
+        {
+          account: manifest.account,
+          cloudProvider: 'kubernetes',
+          location: manifest.location,
+          manifestName: manifest.name,
+          type: ManifestTrafficService.DISABLE_MANIFEST_OPERATION,
+          reason,
+        },
+      ],
+      application,
+      description: `Disable Manifest: ${manifest.name}`,
+    });
+  };
+
+  public static canDisableServerGroup = (serverGroup: IKubernetesServerGroup): boolean => {
+    return (
+      ManifestTrafficService.hasLoadBalancers(serverGroup) &&
+      !ManifestTrafficService.isManaged(serverGroup) &&
+      !serverGroup.disabled
+    );
+  };
+
+  public static canEnableServerGroup = (serverGroup: IKubernetesServerGroup): boolean => {
+    return (
+      ManifestTrafficService.hasLoadBalancers(serverGroup) &&
+      !ManifestTrafficService.isManaged(serverGroup) &&
+      serverGroup.disabled
+    );
+  };
+
+  private static hasLoadBalancers = (serverGroup: IKubernetesServerGroup): boolean => {
+    return serverGroup.loadBalancers?.length > 0;
+  };
+
+  private static isManaged = (serverGroup: IKubernetesServerGroup): boolean => {
+    return serverGroup.serverGroupManagers && serverGroup.serverGroupManagers.length > 0;
+  };
+}

package/src/manifest/wizard/BasicSettings.tsx

@@ -0,0 +1,57 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+
+import type { IAccount } from '@spinnaker/core';
+import { AccountSelectInput, HelpField } from '@spinnaker/core';
+
+import type { IKubernetesManifestCommandData } from '../manifestCommandBuilder.service';
+
+export interface IManifestBasicSettingsProps {
+  accounts: IAccount[];
+  onAccountSelect: (account: string) => void;
+  selectedAccount: string;
+}
+
+export function ManifestBasicSettings({ accounts, onAccountSelect, selectedAccount }: IManifestBasicSettingsProps) {
+  return (
+    <div className="form-horizontal">
+      <div className="form-group">
+        <div className="col-md-3 sm-label-right">
+          Account <HelpField id="kubernetes.manifest.account" />
+        </div>
+        <div className="col-md-7">
+          <AccountSelectInput
+            value={selectedAccount}
+            onChange={(evt: any) => onAccountSelect(evt.target.value)}
+            readOnly={false}
+            accounts={accounts}
+            provider="kubernetes"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export interface IWizardManifestBasicSettingsProps {
+  formik: FormikProps<IKubernetesManifestCommandData>;
+}
+
+export class WizardManifestBasicSettings extends React.Component<IWizardManifestBasicSettingsProps> {
+  private accountUpdated = (account: string): void => {
+    const { formik } = this.props;
+    formik.values.command.account = account;
+    formik.setFieldValue('account', account);
+  };
+
+  public render() {
+    const { formik } = this.props;
+    return (
+      <ManifestBasicSettings
+        accounts={formik.values.metadata.backingData.accounts}
+        onAccountSelect={this.accountUpdated}
+        selectedAccount={formik.values.command.account}
+      />
+    );
+  }
+}

package/src/manifest/wizard/ManifestEntry.tsx

@@ -0,0 +1,46 @@
+import type { FormikProps } from 'formik';
+import { dump } from 'js-yaml';
+import React from 'react';
+
+import type { Application } from '@spinnaker/core';
+import { YamlEditor } from '@spinnaker/core';
+
+import type { IKubernetesManifestCommandData } from '../manifestCommandBuilder.service';
+
+export interface IManifestBasicSettingsProps {
+  app: Application;
+  formik: FormikProps<IKubernetesManifestCommandData>;
+}
+
+export interface IManifestBasicSettingsState {
+  rawManifest: string;
+}
+
+export class ManifestEntry extends React.Component<IManifestBasicSettingsProps, IManifestBasicSettingsState> {
+  constructor(props: IManifestBasicSettingsProps) {
+    super(props);
+
+    const { values } = this.props.formik;
+    const [first = null, ...rest] = values.command.manifests || [];
+    const manifest = rest && rest.length ? values.command.manifests : first;
+    try {
+      this.state = {
+        rawManifest: manifest ? dump(manifest) : null,
+      };
+    } catch (e) {
+      this.state = { rawManifest: null };
+    }
+  }
+
+  private handleChange = (rawManifest: string, manifest: any) => {
+    this.props.formik.setFieldValue(
+      'command.manifests',
+      [].concat(manifest).filter((x) => !!x),
+    );
+    this.setState({ rawManifest });
+  };
+
+  public render() {
+    return <YamlEditor value={this.state.rawManifest} onChange={this.handleChange} />;
+  }
+}

package/src/manifest/wizard/ManifestWizard.tsx

@@ -0,0 +1,94 @@
+import React from 'react';
+
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import { ManifestWriter, noop, ReactModal, TaskMonitor, WizardModal, WizardPage } from '@spinnaker/core';
+
+import { WizardManifestBasicSettings } from './BasicSettings';
+import { ManifestEntry } from './ManifestEntry';
+import type { IKubernetesManifestCommandData } from '../manifestCommandBuilder.service';
+import { KubernetesManifestCommandBuilder } from '../manifestCommandBuilder.service';
+
+export interface IKubernetesManifestModalProps extends IModalComponentProps {
+  title: string;
+  application: Application;
+  command: IKubernetesManifestCommandData;
+  isNew?: boolean;
+}
+
+export interface IKubernetesManifestModalState {
+  command: IKubernetesManifestCommandData;
+  loaded: boolean;
+  taskMonitor: TaskMonitor;
+}
+
+export class ManifestWizard extends React.Component<IKubernetesManifestModalProps, IKubernetesManifestModalState> {
+  public static defaultProps: Partial<IKubernetesManifestModalProps> = {
+    closeModal: noop,
+    dismissModal: noop,
+  };
+
+  public static show(props: IKubernetesManifestModalProps): Promise<IKubernetesManifestCommandData> {
+    const modalProps = { dialogClassName: 'wizard-modal modal-lg' };
+    return ReactModal.show(ManifestWizard, props, modalProps);
+  }
+
+  constructor(props: IKubernetesManifestModalProps) {
+    super(props);
+    if (!props.command) {
+      KubernetesManifestCommandBuilder.buildNewManifestCommand(props.application).then((command) => {
+        Object.assign(this.state.command, command);
+        this.setState({ loaded: true });
+      });
+    }
+
+    this.state = {
+      loaded: !!props.command,
+      command: props.command || ({} as IKubernetesManifestCommandData),
+      taskMonitor: new TaskMonitor({
+        application: props.application,
+        title: `${this.props.isNew ? 'Deploying' : 'Updating'} your manifest`,
+        modalInstance: TaskMonitor.modalInstanceEmulation(() => this.props.dismissModal()),
+      }),
+    };
+  }
+
+  private submit = (c: IKubernetesManifestCommandData): void => {
+    const command = KubernetesManifestCommandBuilder.copyAndCleanCommand(c.command);
+    const submitMethod = () => ManifestWriter.deployManifest(command, this.props.application);
+    this.state.taskMonitor.submit(submitMethod);
+  };
+
+  public render() {
+    const { application, dismissModal, isNew } = this.props;
+    const { loaded, taskMonitor, command } = this.state;
+
+    return (
+      <WizardModal<IKubernetesManifestCommandData>
+        heading={`${isNew ? 'Deploy' : 'Update'} Manifest`}
+        initialValues={command}
+        loading={!loaded}
+        taskMonitor={taskMonitor}
+        dismissModal={dismissModal}
+        closeModal={this.submit}
+        submitButtonLabel={isNew ? 'Create' : 'Edit'}
+        render={({ formik, nextIdx, wizard }) => (
+          <>
+            <WizardPage
+              label="Basic Settings"
+              wizard={wizard}
+              order={nextIdx()}
+              render={({ innerRef }) => <WizardManifestBasicSettings ref={innerRef} formik={formik} />}
+            />
+
+            <WizardPage
+              label="Manifest"
+              wizard={wizard}
+              order={nextIdx()}
+              render={({ innerRef }) => <ManifestEntry ref={innerRef} formik={formik} app={application} />}
+            />
+          </>
+        )}
+      />
+    );
+  }
+}

package/src/pipelines/stages/ManifestCoordinates.spec.tsx

@@ -0,0 +1,90 @@
+import { formatLabelSelectors, SelectorKind } from './ManifestCoordinates';
+
+describe('<ManifestCoordinates />', () => {
+  it('handles ANY', () => {
+    const selectors = {
+      selectors: [
+        {
+          kind: SelectorKind.ANY,
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('');
+  });
+
+  it('handles EQUALS', () => {
+    const selectors = {
+      selectors: [
+        {
+          key: 'environment',
+          kind: SelectorKind.EQUALS,
+          values: ['prod'],
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('environment = prod');
+  });
+
+  it('handles NOT_EQUALS', () => {
+    const selectors = {
+      selectors: [
+        {
+          key: 'environment',
+          kind: SelectorKind.NOT_EQUALS,
+          values: ['prod'],
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('environment != prod');
+  });
+
+  it('handles CONTAINS', () => {
+    const selectors = {
+      selectors: [
+        {
+          key: 'environment',
+          kind: SelectorKind.CONTAINS,
+          values: ['prod', 'staging'],
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('environment in (prod, staging)');
+  });
+
+  it('handles NOT_CONTAINS', () => {
+    const selectors = {
+      selectors: [
+        {
+          key: 'environment',
+          kind: SelectorKind.NOT_CONTAINS,
+          values: ['prod', 'staging'],
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('environment notin (prod, staging)');
+  });
+
+  it('handles EXISTS', () => {
+    const selectors = {
+      selectors: [
+        {
+          key: 'environment',
+          kind: SelectorKind.EXISTS,
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('environment');
+  });
+
+  it('handles NOT_EXISTS', () => {
+    const selectors = {
+      selectors: [
+        {
+          key: 'environment',
+          kind: SelectorKind.NOT_EXISTS,
+        },
+      ],
+    };
+    expect(formatLabelSelectors(selectors)).toEqual('!environment');
+  });
+});

package/src/pipelines/stages/ManifestCoordinates.tsx

@@ -0,0 +1,128 @@
+import { flatten, get } from 'lodash';
+import React from 'react';
+
+import { StageConstants } from '@spinnaker/core';
+
+export interface IManifestCoordinateProps {
+  account: string;
+  manifestName: string;
+  location: string;
+  cluster: string;
+  criteria: string;
+  labelSelectors: ILabelSelectors;
+  manifestNamesByNamespace: IManifestNamesByNamespace;
+}
+
+export interface IManifestNamesByNamespace {
+  [namespace: string]: string[];
+}
+
+export interface ILabelSelectors {
+  selectors: Array<{
+    key?: string;
+    kind: SelectorKind;
+    values?: string[];
+  }>;
+}
+
+export enum SelectorKind {
+  ANY = 'ANY',
+  EQUALS = 'EQUALS',
+  NOT_EQUALS = 'NOT_EQUALS',
+  CONTAINS = 'CONTAINS',
+  NOT_CONTAINS = 'NOT_CONTAINS',
+  EXISTS = 'EXISTS',
+  NOT_EXISTS = 'NOT_EXISTS',
+}
+
+const mapCriteriaToLabel = (criteria: string): string =>
+  get(
+    StageConstants.MANIFEST_CRITERIA_OPTIONS.find((option) => option.val === criteria),
+    'label',
+  );
+
+export const formatLabelSelectors = (labelSelectors: ILabelSelectors): string => {
+  return (labelSelectors.selectors || [])
+    .map((selector) => {
+      const { key, kind, values = [] } = selector;
+      switch (kind) {
+        case SelectorKind.ANY:
+          return null;
+        case SelectorKind.EQUALS:
+          return `${key} = ${values[0]}`;
+        case SelectorKind.NOT_EQUALS:
+          return `${key} != ${values[0]}`;
+        case SelectorKind.CONTAINS:
+          return `${key} in (${values.join(', ')})`;
+        case SelectorKind.NOT_CONTAINS:
+          return `${key} notin (${values.join(', ')})`;
+        case SelectorKind.EXISTS:
+          return `${key}`;
+        case SelectorKind.NOT_EXISTS:
+          return `!${key}`;
+        default:
+          return null;
+      }
+    })
+    .filter((formatted) => !!formatted)
+    .join(', ');
+};
+
+const formatManifestNames = (manifestName: string, manifestNamesByNamespace: IManifestNamesByNamespace) => {
+  if (manifestName) {
+    return (
+      <>
+        <dt>Manifest</dt>
+        <dd>{manifestName}</dd>
+      </>
+    );
+  } else if (manifestNamesByNamespace) {
+    const names = flatten(Object.values(manifestNamesByNamespace));
+    return (
+      <>
+        <dt>
+          Manifest
+          {names.length > 1 ? 's' : ''}
+        </dt>
+        <dd>{names.join(', ')}</dd>
+      </>
+    );
+  } else {
+    return null;
+  }
+};
+
+export const ManifestCoordinates = ({
+  account,
+  manifestName,
+  location,
+  cluster,
+  criteria,
+  labelSelectors,
+  manifestNamesByNamespace,
+}: IManifestCoordinateProps) => {
+  return (
+    <>
+      <dt>Account</dt>
+      <dd>{account}</dd>
+      {formatManifestNames(manifestName, manifestNamesByNamespace)}
+      <dt>Namespace</dt>
+      <dd>{location}</dd>
+      {mapCriteriaToLabel(criteria) != null && cluster != null && (
+        <>
+          <dt>Target</dt>
+          <dd>{`${mapCriteriaToLabel(criteria)} in cluster ${cluster}`}</dd>
+        </>
+      )}
+      {labelSelectors != null && !!formatLabelSelectors(labelSelectors) && (
+        <>
+          <dt>
+            Selector
+            {(labelSelectors.selectors || []).length > 1 ? 's' : ''}
+          </dt>
+          <dd>{formatLabelSelectors(labelSelectors)}</dd>
+        </>
+      )}
+    </>
+  );
+};

package/src/pipelines/stages/ManifestExecutionDetails.tsx

@@ -0,0 +1,58 @@
+import React from 'react';
+
+import type { IExecutionDetailsSectionProps } from '@spinnaker/core';
+import { ExecutionDetailsSection, StageFailureMessage } from '@spinnaker/core';
+
+import type { ILabelSelectors, IManifestNamesByNamespace } from './ManifestCoordinates';
+import { ManifestCoordinates } from './ManifestCoordinates';
+
+interface IManifestExecutionDetailsProps extends IExecutionDetailsSectionProps {
+  context: {
+    account: string;
+    manifestName: string;
+    location: string;
+    cluster: string;
+    criteria: string;
+    labelSelectors: ILabelSelectors;
+    manifestNamesByNamespace: IManifestNamesByNamespace;
+  };
+}
+
+export const manifestExecutionDetails = (stageName: string) => {
+  return class ManifestExecutionDetails extends React.Component<IManifestExecutionDetailsProps> {
+    public static title = stageName;
+
+    public render() {
+      const { stage, current, name } = this.props;
+      const {
+        account,
+        manifestName,
+        location,
+        cluster,
+        criteria,
+        labelSelectors,
+        manifestNamesByNamespace,
+      } = stage.context;
+      return (
+        <ExecutionDetailsSection name={name} current={current}>
+          <div className="row">
+            <div className="col-md-9">
+              <dl className="dl-narrow dl-horizontal">
+                <ManifestCoordinates
+                  account={account}
+                  manifestName={manifestName}
+                  location={location}
+                  cluster={cluster}
+                  criteria={criteria}
+                  labelSelectors={labelSelectors}
+                  manifestNamesByNamespace={manifestNamesByNamespace}
+                />
+              </dl>
+            </div>
+          </div>
+          <StageFailureMessage stage={stage} message={stage.failureMessage} />
+        </ExecutionDetailsSection>
+      );
+    }
+  };
+};