@spinnaker/kubernetes 0.0.0-main-2

package/src/pipelines/stages/runJob/runJobStage.ts

@@ -0,0 +1,39 @@
+import type { ICustomValidator, IPipeline, IStage, IStageOrTriggerTypeConfig, IValidatorConfig } from '@spinnaker/core';
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { KubernetesV2RunJobStageConfig } from './KubernetesV2RunJobStageConfig';
+import { RunJobExecutionDetails } from './RunJobExecutionDetails';
+import { DeployStatus } from '../deployManifest/manifestStatus/DeployStatus';
+
+Registry.pipeline.registerStage({
+  label: 'Run Job (Manifest)',
+  description: 'Run a Kubernetes Job manifest yaml/json file.',
+  key: 'runJobManifest',
+  alias: 'runJob',
+  addAliasToConfig: true,
+  cloudProvider: 'kubernetes',
+  component: KubernetesV2RunJobStageConfig,
+  executionDetailsSections: [RunJobExecutionDetails, DeployStatus, ExecutionDetailsTasks],
+  supportsCustomTimeout: true,
+  producesArtifacts: true,
+  restartable: true,
+  validators: [
+    {
+      type: 'custom',
+      validate: (
+        _pipeline: IPipeline,
+        stage: IStage,
+        _validator: IValidatorConfig,
+        _config: IStageOrTriggerTypeConfig,
+      ): string => {
+        if (!stage.manifest || !stage.manifest.kind) {
+          return '';
+        }
+        if (stage.manifest.kind !== 'Job') {
+          return 'Run Job (Manifest) only accepts manifest of kind Job.';
+        }
+        return '';
+      },
+    } as ICustomValidator,
+  ],
+});

package/src/pipelines/stages/scaleManifest/ScaleManifestConfig.tsx

@@ -0,0 +1,38 @@
+import { defaults } from 'lodash';
+import React, { useEffect } from 'react';
+
+import type { IFormikStageConfigInjectedProps, IStageConfigProps } from '@spinnaker/core';
+import { FormikStageConfig } from '@spinnaker/core';
+
+import { ScaleManifestStageForm } from './ScaleManifestStageForm';
+
+export function ScaleManifestStageConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+  stageFieldUpdated,
+}: IStageConfigProps) {
+  useEffect(() => {
+    defaults(stage, {
+      app: application.name,
+      cloudProvider: 'kubernetes',
+    });
+
+    if (stage.isNew) {
+      stage.replicas = 0;
+    }
+  }, []);
+
+  return (
+    <FormikStageConfig
+      application={application}
+      pipeline={pipeline}
+      stage={stage}
+      onChange={updateStage}
+      render={(props: IFormikStageConfigInjectedProps) => (
+        <ScaleManifestStageForm {...props} stageFieldUpdated={stageFieldUpdated} />
+      )}
+    />
+  );
+}

package/src/pipelines/stages/scaleManifest/ScaleManifestStageForm.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+
+import type { IFormikStageConfigInjectedProps } from '@spinnaker/core';
+
+import type { IScaleCommand } from '../../../manifest';
+import { ScaleSettingsForm } from '../../../manifest/scale/ScaleSettingsForm';
+import type { IManifestSelector } from '../../../manifest/selector/IManifestSelector';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+import { ManifestSelector } from '../../../manifest/selector/ManifestSelector';
+
+interface IScaleManifestStageConfigFormProps {
+  stageFieldUpdated: () => void;
+}
+
+export function ScaleManifestStageForm({
+  application,
+  formik,
+  stageFieldUpdated,
+}: IScaleManifestStageConfigFormProps & IFormikStageConfigInjectedProps) {
+  const stage = formik.values;
+
+  const onManifestSelectorChange = () => {
+    stageFieldUpdated();
+  };
+
+  const onScaleSettingsFormChange = () => {
+    stageFieldUpdated();
+  };
+
+  return (
+    <div className="form-horizontal">
+      <h4>Manifest</h4>
+      <div className="horizontal-rule" />
+      <ManifestSelector
+        application={application}
+        selector={(stage as unknown) as IManifestSelector}
+        modes={[SelectorMode.Static, SelectorMode.Dynamic]}
+        onChange={onManifestSelectorChange}
+        includeSpinnakerKinds={null}
+      />
+      <h4>Settings</h4>
+      <div className="horizontal-rule" />
+      <ScaleSettingsForm options={(stage as unknown) as IScaleCommand} onChange={onScaleSettingsFormChange} />
+    </div>
+  );
+}

package/src/pipelines/stages/scaleManifest/scaleManifestStage.ts

@@ -0,0 +1,24 @@
+import type { IStage } from '@spinnaker/core';
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { manifestExecutionDetails } from '../ManifestExecutionDetails';
+import { ScaleManifestStageConfig } from './ScaleManifestConfig';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+const STAGE_NAME = 'Scale (Manifest)';
+const STAGE_KEY = 'scaleManifest';
+
+Registry.pipeline.registerStage({
+  label: STAGE_NAME,
+  description: 'Scale a Kubernetes object created from a manifest.',
+  key: STAGE_KEY,
+  cloudProvider: 'kubernetes',
+  component: ScaleManifestStageConfig,
+  executionDetailsSections: [manifestExecutionDetails(STAGE_KEY), ExecutionDetailsTasks],
+  accountExtractor: (stage: IStage): string[] => (stage.context.account ? [stage.context.account] : []),
+  configAccountExtractor: (stage: any): string[] => (stage.account ? [stage.account] : []),
+  validators: [
+    ...manifestSelectorValidators(STAGE_NAME),
+    { type: 'requiredField', fieldName: 'replicas', fieldLabel: 'Replicas' },
+  ],
+});

package/src/pipelines/stages/traffic/ManifestTrafficStageConfig.tsx

@@ -0,0 +1,44 @@
+import { defaults } from 'lodash';
+import React from 'react';
+
+import type { IStage, IStageConfigProps } from '@spinnaker/core';
+
+import type { IManifestSelector } from '../../../manifest/selector/IManifestSelector';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+import { ManifestSelector } from '../../../manifest/selector/ManifestSelector';
+
+export interface IKubernetesManifestStageConfigProps extends IStageConfigProps {
+  stage: IManifestSelector & IStage;
+}
+
+export class ManifestTrafficStageConfig extends React.Component<IKubernetesManifestStageConfigProps> {
+  public componentDidMount = (): void => {
+    defaults(this.props.stage, {
+      app: this.props.application.name,
+      cloudProvider: 'kubernetes',
+    });
+    this.props.stageFieldUpdated();
+  };
+
+  private onChange = (stage: IManifestSelector): void => {
+    Object.assign(this.props.stage, stage);
+    this.props.stageFieldUpdated();
+  };
+
+  public render() {
+    const selector = { ...this.props.stage };
+    return (
+      <div className="form-horizontal">
+        <h4>Manifest</h4>
+        <div className="horizontal-rule" />
+        <ManifestSelector
+          application={this.props.application}
+          selector={selector}
+          modes={[SelectorMode.Static, SelectorMode.Dynamic]}
+          onChange={this.onChange}
+          includeSpinnakerKinds={['serverGroups']}
+        />
+      </div>
+    );
+  }
+}

package/src/pipelines/stages/traffic/disableManifest.stage.ts

@@ -0,0 +1,26 @@
+import { module } from 'angular';
+
+import type { IStage } from '@spinnaker/core';
+import { EXECUTION_ARTIFACT_TAB, ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { manifestExecutionDetails } from '../ManifestExecutionDetails';
+import { ManifestTrafficStageConfig } from './ManifestTrafficStageConfig';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+const STAGE_NAME = 'Disable (Manifest)';
+const STAGE_KEY = 'disableManifest';
+export const KUBERNETES_DISABLE_MANIFEST_STAGE = 'spinnaker.kubernetes.v2.pipeline.stage.disableManifestStage';
+module(KUBERNETES_DISABLE_MANIFEST_STAGE, [EXECUTION_ARTIFACT_TAB]).config(() => {
+  Registry.pipeline.registerStage({
+    label: STAGE_NAME,
+    description: 'Disable a Kubernetes manifest.',
+    key: STAGE_KEY,
+    cloudProvider: 'kubernetes',
+    component: ManifestTrafficStageConfig,
+    executionDetailsSections: [manifestExecutionDetails(STAGE_KEY), ExecutionDetailsTasks],
+    supportsCustomTimeout: true,
+    accountExtractor: (stage: IStage): string[] => (stage.account ? [stage.account] : []),
+    configAccountExtractor: (stage: IStage): string[] => (stage.account ? [stage.account] : []),
+    validators: manifestSelectorValidators(STAGE_NAME),
+  });
+});

package/src/pipelines/stages/traffic/enableManifest.stage.ts

@@ -0,0 +1,26 @@
+import { module } from 'angular';
+
+import type { IStage } from '@spinnaker/core';
+import { EXECUTION_ARTIFACT_TAB, ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { manifestExecutionDetails } from '../ManifestExecutionDetails';
+import { ManifestTrafficStageConfig } from './ManifestTrafficStageConfig';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+const STAGE_NAME = 'Enable (Manifest)';
+const STAGE_KEY = 'enableManifest';
+export const KUBERNETES_ENABLE_MANIFEST_STAGE = 'spinnaker.kubernetes.v2.pipeline.stage.enableManifestStage';
+module(KUBERNETES_ENABLE_MANIFEST_STAGE, [EXECUTION_ARTIFACT_TAB]).config(() => {
+  Registry.pipeline.registerStage({
+    label: STAGE_NAME,
+    description: 'Enable a Kubernetes manifest.',
+    key: STAGE_KEY,
+    cloudProvider: 'kubernetes',
+    component: ManifestTrafficStageConfig,
+    executionDetailsSections: [manifestExecutionDetails(STAGE_KEY), ExecutionDetailsTasks],
+    supportsCustomTimeout: true,
+    accountExtractor: (stage: IStage): string[] => (stage.account ? [stage.account] : []),
+    configAccountExtractor: (stage: IStage): string[] => (stage.account ? [stage.account] : []),
+    validators: manifestSelectorValidators(STAGE_NAME),
+  });
+});

package/src/pipelines/stages/undoRolloutManifest/UndoRolloutManifestConfig.tsx

@@ -0,0 +1,37 @@
+import { defaults } from 'lodash';
+import React, { useEffect } from 'react';
+
+import type { IFormikStageConfigInjectedProps, IStageConfigProps } from '@spinnaker/core';
+import { FormikStageConfig } from '@spinnaker/core';
+
+import { UndoRolloutManifestStageForm } from './UndoRolloutManifestStageForm';
+
+export function UndoRolloutManifestConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+  stageFieldUpdated,
+}: IStageConfigProps) {
+  useEffect(() => {
+    defaults(stage, {
+      cloudProvider: 'kubernetes',
+    });
+
+    if (stage.isNew) {
+      stage.numRevisionsBack = 1;
+    }
+  }, []);
+
+  return (
+    <FormikStageConfig
+      application={application}
+      pipeline={pipeline}
+      stage={stage}
+      onChange={updateStage}
+      render={(props: IFormikStageConfigInjectedProps) => (
+        <UndoRolloutManifestStageForm {...props} stageFieldUpdated={stageFieldUpdated} />
+      )}
+    />
+  );
+}

package/src/pipelines/stages/undoRolloutManifest/UndoRolloutManifestStageForm.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+
+import type { IFormikStageConfigInjectedProps } from '@spinnaker/core';
+import { NumberInput, StageConfigField } from '@spinnaker/core';
+
+import type { IManifestSelector } from '../../../manifest/selector/IManifestSelector';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+import { ManifestSelector } from '../../../manifest/selector/ManifestSelector';
+
+interface IUndoRolloutManifestStageConfigFormProps {
+  stageFieldUpdated: () => void;
+}
+
+export function UndoRolloutManifestStageForm({
+  application,
+  formik,
+  stageFieldUpdated,
+}: IUndoRolloutManifestStageConfigFormProps & IFormikStageConfigInjectedProps) {
+  const stage = formik.values;
+
+  const onManifestSelectorChange = () => {
+    stageFieldUpdated();
+  };
+
+  const onRevisionsChange = (e: React.ChangeEvent<any>) => {
+    formik.setFieldValue('numRevisionsBack', e.target.value);
+  };
+
+  return (
+    <div className="form-horizontal">
+      <h4>Manifest</h4>
+      <div className="horizontal-rule" />
+      <ManifestSelector
+        application={application}
+        selector={(stage as unknown) as IManifestSelector}
+        modes={[SelectorMode.Static, SelectorMode.Dynamic]}
+        onChange={onManifestSelectorChange}
+        includeSpinnakerKinds={null}
+      />
+      <h4>Settings</h4>
+      <div className="horizontal-rule" />
+      <StageConfigField
+        label="Revisions Back"
+        helpKey="kubernetes.manifest.undoRollout.revisionsBack"
+        fieldColumns={4}
+        groupClassName="form-group form-inline"
+      >
+        <div className="input-group">
+          <NumberInput
+            inputClassName="input-sm highlight-pristine"
+            onChange={onRevisionsChange}
+            value={stage.numRevisionsBack}
+            min={1}
+          />
+          <span className="input-group-addon">{stage.numRevisionsBack === '1' ? 'revision' : 'revisions'}</span>
+        </div>
+      </StageConfigField>
+    </div>
+  );
+}

package/src/pipelines/stages/undoRolloutManifest/undoRolloutManifestStage.ts

@@ -0,0 +1,21 @@
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { manifestExecutionDetails } from '../ManifestExecutionDetails';
+import { UndoRolloutManifestConfig } from './UndoRolloutManifestConfig';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+const STAGE_NAME = 'Undo Rollout (Manifest)';
+const STAGE_KEY = 'undoRolloutManifest';
+
+Registry.pipeline.registerStage({
+  label: STAGE_NAME,
+  description: 'Rollback a manifest a target number of revisions.',
+  key: STAGE_KEY,
+  cloudProvider: 'kubernetes',
+  component: UndoRolloutManifestConfig,
+  executionDetailsSections: [manifestExecutionDetails(STAGE_KEY), ExecutionDetailsTasks],
+  validators: [
+    ...manifestSelectorValidators(STAGE_NAME),
+    { type: 'requiredField', fieldName: 'numRevisionsBack', fieldLabel: 'Number of Revisions' },
+  ],
+});

package/src/pipelines/stages/validators/manifestSelectorValidators.ts

@@ -0,0 +1,43 @@
+import type { ICustomValidator, IPipeline, IStage, IValidatorConfig } from '@spinnaker/core';
+
+import type { IManifestSelector } from '../../../manifest/selector/IManifestSelector';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+
+export const manifestSelectorValidators = (stageName: string): IValidatorConfig[] => {
+  const required = (field: string) => `<strong>${field}</strong> is a required field for ${stageName} stages.`;
+
+  return [
+    { type: 'requiredField', fieldName: 'location', fieldLabel: 'Namespace' },
+    { type: 'requiredField', fieldName: 'account', fieldLabel: 'Account' },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, stage: IManifestSelector & IStage) => {
+        if (stage.mode === SelectorMode.Dynamic) {
+          if (!stage.kind) {
+            return required('Kind');
+          }
+          if (!stage.cluster) {
+            return required('Cluster');
+          }
+          if (!stage.criteria) {
+            return required('Target');
+          }
+        } else if (stage.mode === SelectorMode.Static) {
+          const [kind] = (stage.manifestName || '').split(' ');
+          if (!kind) {
+            return required('Kind');
+          }
+          const [, name] = (stage.manifestName || '').split(' ');
+          if (!name) {
+            return required('Name');
+          }
+        } else if (stage.mode === SelectorMode.Label) {
+          if (!stage.kinds) {
+            return required('Kinds');
+          }
+        }
+        return null;
+      },
+    } as ICustomValidator,
+  ];
+};

package/src/pipelines/validation/manifestSelector.validator.ts

@@ -0,0 +1,36 @@
+import type {
+  IPipeline,
+  IStage,
+  IStageOrTriggerTypeConfig,
+  IStageOrTriggerValidator,
+  IValidatorConfig,
+} from '@spinnaker/core';
+import { PipelineConfigValidator } from '@spinnaker/core';
+
+export interface IStageWithManifestSelector extends IStage {
+  manifestName: string;
+  location: string;
+}
+
+export class ManifestSelectorValidator implements IStageOrTriggerValidator {
+  public validate(
+    _pipeline: IPipeline,
+    stage: IStageWithManifestSelector,
+    _validator: IValidatorConfig,
+    _config: IStageOrTriggerTypeConfig,
+  ): string {
+    const [kind, name] = (stage.manifestName || '').split(' ');
+    if (!name && !kind) {
+      return `<strong>Name</strong> and <strong>Kind</strong> are required fields.`;
+    }
+    if (!name) {
+      return `<strong>Name</strong> is a required field.`;
+    }
+    if (!kind) {
+      return `<strong>Kind</strong> is a required field.`;
+    }
+    return null;
+  }
+}
+
+PipelineConfigValidator.registerValidator('manifestSelector', new ManifestSelectorValidator());

package/src/rawResource/component/K8sResources.less

@@ -0,0 +1,9 @@
+.K8sResources {
+  width: 100%;
+  .StandardFieldLayout {
+    width: 25%;
+    .StandardFieldLayout_Label {
+      min-width: 72px;
+    }
+  }
+}

package/src/rawResource/component/K8sResources.tsx

@@ -0,0 +1,112 @@
+import React from 'react';
+
+import type { Application, ApplicationDataSource } from '@spinnaker/core';
+import { FormField, ReactSelectInput } from '@spinnaker/core';
+
+import type { IK8sResourcesFiltersState } from './K8sResourcesFilters';
+import { RawResourceUtils } from './RawResourceUtils';
+import { FiltersPubSub } from '../controller/FiltersPubSub';
+import { RawResource } from './group/RawResource';
+import { RawResourceGroups } from './group/RawResourceGroups';
+import { KUBERNETS_RAW_RESOURCE_DATA_SOURCE_KEY } from '../rawResource.dataSource';
+
+import './K8sResources.less';
+
+export interface IK8sResourcesProps {
+  app: Application;
+}
+
+interface IK8sResourcesState {
+  groupBy: string;
+  filters: IK8sResourcesFiltersState;
+  rawResources: IApiKubernetesResource[];
+}
+
+export class K8sResources extends React.Component<IK8sResourcesProps, IK8sResourcesState> {
+  private dataSource: ApplicationDataSource<IApiKubernetesResource[]>;
+  private filterPubSub: FiltersPubSub = FiltersPubSub.getInstance(this.props.app.name);
+  private sub = this.onFilterChange.bind(this);
+
+  constructor(props: IK8sResourcesProps) {
+    super(props);
+    this.dataSource = this.props.app.getDataSource(KUBERNETS_RAW_RESOURCE_DATA_SOURCE_KEY);
+    this.state = {
+      groupBy: 'none',
+      filters: null,
+      rawResources: [],
+    };
+
+    this.filterPubSub.subscribe(this.sub);
+  }
+
+  public componentWillUnmount() {
+    this.filterPubSub.unsubscribe(this.sub);
+  }
+
+  public onFilterChange(message: IK8sResourcesFiltersState) {
+    this.setState({ ...this.state, filters: message });
+  }
+
+  public async componentDidMount() {
+    await this.dataSource.ready();
+
+    this.setState({
+      ...this.state,
+      groupBy: this.state.groupBy,
+      rawResources: await this.dataSource.data.sort((a, b) => a.name.localeCompare(b.name)),
+    });
+  }
+
+  private groupByChanged = (e: React.ChangeEvent<any>): void => {
+    this.setState({ groupBy: e.target.value.toLowerCase() });
+  };
+
+  public render() {
+    const opts = ['None', 'Account', 'Kind', 'Namespace'];
+    return (
+      <div className="K8sResources">
+        <div className="header row">
+          <FormField
+            onChange={this.groupByChanged}
+            value={this.state.groupBy.charAt(0).toUpperCase() + this.state.groupBy.substr(1)}
+            name="groupBy"
+            label="Group By"
+            input={(props) => (
+              <ReactSelectInput {...props} inputClassName="groupby" stringOptions={opts} clearable={false} />
+            )}
+          />
+        </div>
+        <div className="content">
+          {this.state.groupBy === 'none' ? (
+            <>
+              {...this.state.rawResources
+                .filter((resource) => this.matchFilters(resource))
+                .map((resource) => (
+                  <RawResource key={RawResourceUtils.resourceKey(resource)} resource={resource}></RawResource>
+                ))}
+            </>
+          ) : (
+            <RawResourceGroups
+              resources={this.state.rawResources.filter((resource) => this.matchFilters(resource))}
+              groupBy={this.state.groupBy}
+            ></RawResourceGroups>
+          )}
+        </div>
+      </div>
+    );
+  }
+
+  private matchFilters(resource: IApiKubernetesResource) {
+    if (this.state.filters == null) {
+      return true;
+    }
+    const accountMatch =
+      Object.values(this.state.filters.accounts).every((x) => !x) || this.state.filters.accounts[resource.account];
+    const kindMatch =
+      Object.values(this.state.filters.kinds).every((x) => !x) || this.state.filters.kinds[resource.kind];
+    const namespaceMatch =
+      Object.values(this.state.filters.namespaces).every((x) => !x) ||
+      this.state.filters.namespaces[resource.namespace];
+    return accountMatch && kindMatch && namespaceMatch;
+  }
+}