@spinnaker/kubernetes 0.0.0-main-2

package/src/pipelines/stages/deployManifest/NamespaceSelector.tsx

@@ -0,0 +1,40 @@
+import { find, get, map } from 'lodash';
+import React from 'react';
+import type { Option } from 'react-select';
+import Select, { Creatable } from 'react-select';
+
+import type { IAccountDetails } from '@spinnaker/core';
+
+export interface INamespaceSelectorProps {
+  onChange: (namespace: string) => void;
+  accounts: IAccountDetails[];
+  selectedAccount: string;
+  selectedNamespace: string;
+  createable?: boolean;
+}
+
+export class NamespaceSelector extends React.Component<INamespaceSelectorProps> {
+  public defaultProps = { createable: false };
+
+  private getNamespaceOptions(): Array<Option<string>> {
+    const { accounts, selectedAccount, selectedNamespace } = this.props;
+    const selectedAccountDetails = find(accounts, (a) => a.name === selectedAccount);
+    const namespaces = get(selectedAccountDetails, 'namespaces', []);
+    const options = map(namespaces, (n) => ({ label: n, value: n }));
+    // only create a value for selectedNamespace if it contains a SPeL expression
+    if (this.props.createable && selectedNamespace.includes('${')) {
+      options.push({ label: selectedNamespace, value: selectedNamespace });
+    }
+    return options;
+  }
+
+  public render() {
+    const componentProps = {
+      clearable: false,
+      options: this.getNamespaceOptions(),
+      value: this.props.selectedNamespace,
+      onChange: (option: Option) => this.props.onChange(option.value.toString()),
+    };
+    return this.props.createable ? <Creatable {...componentProps} /> : <Select {...componentProps} />;
+  }
+}

package/src/pipelines/stages/deployManifest/deployManifest.validator.ts

@@ -0,0 +1,38 @@
+import { get, isEmpty } from 'lodash';
+
+import type { ICustomValidator, IPipeline, IStage, IValidatorConfig } from '@spinnaker/core';
+
+import { ManifestSource } from '../../../manifest/ManifestSource';
+import { strategyRedBlack } from '../../../rolloutStrategy/redblack.strategy';
+
+const MAX_VERSION_HISTORY_ANNOTATION = 'strategy.spinnaker.io/max-version-history';
+
+export const deployManifestValidators = (): IValidatorConfig[] => {
+  return [
+    { type: 'requiredField', fieldName: 'account', fieldLabel: 'Account' },
+    { type: 'requiredField', fieldName: 'source', fieldLabel: 'Source' },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, stage: IStage) => {
+        const enabled = get(stage, 'trafficManagement.enabled', false);
+        const services = get(stage, 'trafficManagement.options.services', []);
+        if (enabled && isEmpty(services)) {
+          return `Select at least one <strong>Service</strong> to enable Spinnaker-managed rollout strategy options.`;
+        }
+        if (enabled && stage.source === ManifestSource.TEXT) {
+          const manifests = get(stage, 'manifests', []);
+          const replicaSetManifests = manifests.filter((m) => m.kind === 'ReplicaSet');
+          const strategy = get(stage, 'trafficManagement.options.strategy');
+          const maxVersionHistory = parseInt(
+            get(replicaSetManifests, [0, 'metadata', 'annotations', MAX_VERSION_HISTORY_ANNOTATION]),
+            10,
+          );
+          if (strategy === strategyRedBlack.key && maxVersionHistory < 2) {
+            return `The max version history specified in your manifest conflicts with the behavior of the Red/Black rollout strategy. Please update your <strong>${MAX_VERSION_HISTORY_ANNOTATION}</strong> annotation to a value greater than or equal to 2.`;
+          }
+        }
+        return null;
+      },
+    } as ICustomValidator,
+  ];
+};

package/src/pipelines/stages/deployManifest/deployManifestStage.ts

@@ -0,0 +1,28 @@
+import type { IStage } from '@spinnaker/core';
+import {
+  ArtifactReferenceService,
+  ExecutionArtifactTab,
+  ExecutionDetailsTasks,
+  ExpectedArtifactService,
+  Registry,
+} from '@spinnaker/core';
+
+import { DeployManifestStageConfig } from './DeployManifestStageConfig';
+import { deployManifestValidators } from './deployManifest.validator';
+import { DeployStatus } from './manifestStatus/DeployStatus';
+
+Registry.pipeline.registerStage({
+  label: 'Deploy (Manifest)',
+  description: 'Deploy a Kubernetes manifest yaml/json file.',
+  key: 'deployManifest',
+  cloudProvider: 'kubernetes',
+  component: DeployManifestStageConfig,
+  executionDetailsSections: [DeployStatus, ExecutionDetailsTasks, ExecutionArtifactTab],
+  producesArtifacts: true,
+  supportsCustomTimeout: true,
+  validators: deployManifestValidators(),
+  accountExtractor: (stage: IStage): string[] => (stage.context.account ? [stage.context.account] : []),
+  configAccountExtractor: (stage: any): string[] => (stage.account ? [stage.account] : []),
+  artifactExtractor: ExpectedArtifactService.accumulateArtifacts(['manifestArtifactId', 'requiredArtifactIds']),
+  artifactRemover: ArtifactReferenceService.removeArtifactFromFields(['manifestArtifactId', 'requiredArtifactIds']),
+});

package/src/pipelines/stages/deployManifest/manifestStatus/DeployStatus.less

@@ -0,0 +1,11 @@
+.deploy-status .collapsible-element {
+  margin-bottom: 20px;
+
+  .alert {
+    margin-bottom: 0;
+  }
+
+  .content {
+    padding: 0;
+  }
+}

package/src/pipelines/stages/deployManifest/manifestStatus/DeployStatus.tsx

@@ -0,0 +1,120 @@
+import { get } from 'lodash';
+import React from 'react';
+
+import type { IExecutionDetailsSectionProps, IManifest } from '@spinnaker/core';
+import { CollapsibleElement, ExecutionDetailsSection, SETTINGS, StageFailureMessage } from '@spinnaker/core';
+
+import { ManifestStatus } from './ManifestStatus';
+import type { IStageManifest } from '../../../../manifest/manifest.service';
+import { KubernetesManifestService } from '../../../../manifest/manifest.service';
+
+import './DeployStatus.less';
+
+export interface IManifestSubscription {
+  id: string;
+  unsubscribe: () => void;
+  manifest: IManifest;
+}
+
+export interface IDeployStatusState {
+  subscriptions: IManifestSubscription[];
+  manifestIds: string[];
+}
+
+export class DeployStatus extends React.Component<IExecutionDetailsSectionProps, IDeployStatusState> {
+  public static title = 'deployStatus';
+
+  constructor(props: IExecutionDetailsSectionProps) {
+    super(props);
+    this.state = { subscriptions: [], manifestIds: [] };
+  }
+
+  public componentDidMount() {
+    this.componentDidUpdate(this.props, this.state);
+  }
+
+  public componentWillUnmount() {
+    this.unsubscribeAll();
+  }
+
+  public componentDidUpdate(_prevProps: IExecutionDetailsSectionProps, prevState: IDeployStatusState) {
+    const manifests: IStageManifest[] = get(this.props.stage, ['context', 'outputs.manifests'], []).filter((m) => !!m);
+    const manifestIds = manifests.map((m) => KubernetesManifestService.manifestIdentifier(m)).sort();
+    if (prevState.manifestIds.join('') !== manifestIds.join('')) {
+      this.unsubscribeAll();
+      const subscriptions = manifests.map((manifest) => {
+        const id = KubernetesManifestService.manifestIdentifier(manifest);
+        return {
+          id,
+          unsubscribe: this.subscribeToManifestUpdates(id, manifest),
+          manifest: this.stageManifestToIManifest(manifest, this.props.stage.context.account),
+        };
+      });
+      this.setState({ subscriptions, manifestIds });
+    }
+  }
+
+  private subscribeToManifestUpdates(id: string, manifest: IStageManifest): () => void {
+    const params = KubernetesManifestService.stageManifestToManifestParams(manifest, this.props.stage.context.account);
+    return KubernetesManifestService.subscribe(this.props.application, params, (updated: IManifest) => {
+      const idx = this.state.subscriptions.findIndex((sub) => sub.id === id);
+      if (idx !== -1) {
+        const subscription = { ...this.state.subscriptions[idx], manifest: updated };
+        const subscriptions = [...this.state.subscriptions];
+        subscriptions[idx] = subscription;
+        this.setState({ subscriptions });
+      }
+    });
+  }
+
+  private unsubscribeAll() {
+    this.state.subscriptions.forEach(({ unsubscribe }) => unsubscribe());
+  }
+
+  private stageManifestToIManifest(manifest: IStageManifest, account: string): IManifest {
+    return {
+      name: get(manifest, 'metadata.name', ''),
+      moniker: null,
+      account,
+      cloudProvider: 'kubernetes',
+      location: get(manifest, 'metadata.namespace', ''),
+      manifest: manifest,
+      status: {},
+      artifacts: [],
+      events: [],
+    };
+  }
+
+  public render() {
+    const { name: sectionName, current: currentSection, stage } = this.props;
+    const manifests: IManifest[] = this.state.subscriptions.filter((sub) => !!sub.manifest).map((sub) => sub.manifest);
+    return (
+      <div className="deploy-status">
+        <ExecutionDetailsSection name={sectionName} current={currentSection}>
+          {SETTINGS.feature.multiBlockFailureMessages ? (
+            stage.failureMessages.map((failureMessage) => (
+              <CollapsibleElement key={failureMessage} maxHeight={150}>
+                <StageFailureMessage stage={stage} message={failureMessage} />
+              </CollapsibleElement>
+            ))
+          ) : (
+            <StageFailureMessage stage={stage} message={stage.failureMessage} />
+          )}
+          {!!manifests?.length && (
+            <div className="row">
+              <div className="col-md-12">
+                <div className="well alert alert-info">
+                  {manifests.map((manifest) => {
+                    const uid =
+                      manifest.manifest.metadata.uid || KubernetesManifestService.manifestIdentifier(manifest.manifest);
+                    return <ManifestStatus key={uid} manifest={manifest} account={stage.context.account} />;
+                  })}
+                </div>
+              </div>
+            </div>
+          )}
+        </ExecutionDetailsSection>
+      </div>
+    );
+  }
+}

package/src/pipelines/stages/deployManifest/manifestStatus/DeployStatusPills.tsx

@@ -0,0 +1,47 @@
+import React from 'react';
+import type { IManifest } from '@spinnaker/core';
+
+interface IStatusClasses {
+  [key: string]: string;
+}
+
+const STATUS_PILLS: IStatusClasses = {
+  available: 'success',
+  stable: 'success',
+  paused: 'warn',
+  failed: 'danger',
+};
+
+export interface IDeployManifestStatusProps {
+  manifest: IManifest;
+}
+
+export class DeployManifestStatusPills extends React.Component<IDeployManifestStatusProps> {
+  public render() {
+    const { manifest } = this.props;
+    if (manifest == null || manifest.status == null) {
+      return null;
+    }
+    return Object.keys(manifest.status).map((statusKey, i) => {
+      const statusDescription = manifest.status[statusKey];
+      const statusClass = STATUS_PILLS[statusKey] || '';
+      const isStable = statusDescription.state;
+      const isUnstableWithMessage = !isStable && statusDescription.message;
+      return (
+        <span key={i}>
+          {isStable && (
+            <span title={statusDescription.message} className={`pill ${statusClass}`}>
+              {statusKey}
+            </span>
+          )}
+          {isUnstableWithMessage && (
+            <span title={statusDescription.message} className="pill warn">
+              {statusKey}
+            </span>
+          )}
+          {(isStable || isUnstableWithMessage) && <span>&nbsp;</span>}
+        </span>
+      );
+    });
+  }
+}

package/src/pipelines/stages/deployManifest/manifestStatus/ManifestDetailsLink.tsx

@@ -0,0 +1,92 @@
+import { get, trim } from 'lodash';
+import React from 'react';
+
+import type { IManifest } from '@spinnaker/core';
+import { AccountService, ReactInjector } from '@spinnaker/core';
+
+const UNMAPPED_K8S_RESOURCE_STATE_KEY = 'kubernetesResource';
+
+export interface IManifestDetailsProps {
+  manifest: IManifest;
+  linkName: string;
+  accountId: string;
+}
+
+export interface IManifestDetailsState {
+  url: string;
+}
+
+export class ManifestDetailsLink extends React.Component<IManifestDetailsProps, IManifestDetailsState> {
+  private spinnakerKindStateMap: { [k: string]: string } = {
+    // keys from clouddriver's KubernetesSpinnakerKindMap
+    serverGroupManagers: 'serverGroupManager',
+    serverGroups: 'serverGroup',
+  };
+
+  constructor(props: IManifestDetailsProps) {
+    super(props);
+    this.state = {
+      url: '',
+    };
+    this.loadUrl();
+  }
+
+  private canOpen(): boolean {
+    return !!this.props.manifest.manifest && !!this.state.url;
+  }
+
+  private spinnakerKindFromKubernetesKind(kind: string, kindMap: { [k: string]: string }) {
+    const foundKind = Object.keys(kindMap).find((k) => k.toLowerCase() === kind.toLowerCase());
+    return kindMap[foundKind];
+  }
+
+  private resourceRegion(): string {
+    return trim(
+      get(this.props, ['manifest', 'manifest', 'metadata', 'annotations', 'artifact.spinnaker.io/location'], ''),
+    );
+  }
+
+  private getStateParams(stateKey: string): any {
+    const kind = this.props.manifest.manifest.kind.toLowerCase();
+    const name = this.props.manifest.manifest.metadata.name;
+    const region = this.resourceRegion();
+    const params: { [k: string]: string } = {
+      accountId: this.props.accountId,
+      provider: 'kubernetes',
+      region,
+      reg: region, // Filters the list of clusters on the Clusters screen to those in the same namespace
+      [stateKey]: `${kind} ${name}`,
+    };
+    if (!params.region && kind === 'namespace' && stateKey === UNMAPPED_K8S_RESOURCE_STATE_KEY) {
+      params.region = name;
+    }
+    if (!params.region || params.region === '') {
+      params.region = '_';
+    }
+    return params;
+  }
+
+  private loadUrl() {
+    const kind: string = get(this.props, ['manifest', 'manifest', 'kind'], '');
+    const { accountId } = this.props;
+    AccountService.getAccountDetails(accountId).then((account) => {
+      const spinnakerKind = this.spinnakerKindFromKubernetesKind(kind, account.spinnakerKindMap);
+      const stateKey = this.spinnakerKindStateMap[spinnakerKind] || UNMAPPED_K8S_RESOURCE_STATE_KEY;
+      const params = this.getStateParams(stateKey);
+      const url = ReactInjector.$state.href(`home.applications.application.insight.clusters.${stateKey}`, params);
+      this.setState({ url });
+    });
+  }
+
+  public render() {
+    if (this.canOpen()) {
+      return (
+        <a href={this.state.url} className="clickable">
+          {this.props.linkName}
+        </a>
+      );
+    } else {
+      return null;
+    }
+  }
+}

package/src/pipelines/stages/deployManifest/manifestStatus/ManifestEvents.tsx

@@ -0,0 +1,87 @@
+import { get, trim } from 'lodash';
+import { DateTime } from 'luxon';
+import React from 'react';
+
+import type { IManifest, IManifestEvent } from '@spinnaker/core';
+import { JobEventBasedPodNameProvider, JobManifestPodLogs, relativeTime } from '@spinnaker/core';
+
+export interface IManifestEventsProps {
+  manifest: IManifest;
+}
+
+export class ManifestEvents extends React.Component<IManifestEventsProps> {
+  private pillStyle(e: IManifestEvent): string {
+    if (e.type === 'Warning') {
+      return 'alert';
+    } else if (e.type === 'Normal') {
+      return 'success';
+    } else {
+      return '';
+    }
+  }
+
+  public render() {
+    if (!this.props.manifest) {
+      return null;
+    }
+    if (this.props.manifest && (!this.props.manifest.events || this.props.manifest.events.length === 0)) {
+      return <div>No recent events found - Kubernetes does not store events for long.</div>;
+    }
+    const { events } = this.props.manifest;
+    const namespace = trim(
+      get(this.props.manifest, ['manifest', 'metadata', 'annotations', 'artifact.spinnaker.io/location'], ''),
+    );
+    return events.map((e, i) => {
+      const firstTimestamp = get(e, 'firstTimestamp', '');
+      const lastTimestamp = get(e, 'lastTimestamp', '');
+      let firstEpochMilliseconds = 0;
+      let lastEpochMilliseconds = 0;
+      if (firstTimestamp) {
+        firstEpochMilliseconds = DateTime.fromISO(firstTimestamp).toMillis();
+      }
+      if (lastTimestamp) {
+        lastEpochMilliseconds = DateTime.fromISO(lastTimestamp).toMillis();
+      }
+      return (
+        <div key={get(e, ['metadata', 'uid'], String(i))} className="info">
+          <div className="horizontal">
+            {e.count && (
+              <div className={`pill ${this.pillStyle(e)}`}>
+                {e.count} × <b>{e.reason}</b>
+              </div>
+            )}
+          </div>
+          {(e.firstTimestamp || e.lastTimestamp) && (
+            <div>
+              {e.firstTimestamp === e.lastTimestamp && (
+                <div>
+                  <i>{relativeTime(firstEpochMilliseconds)}</i>
+                </div>
+              )}
+              {e.firstTimestamp !== e.lastTimestamp && (
+                <div>
+                  <div>
+                    First Occurrence: <i>{relativeTime(firstEpochMilliseconds)}</i>
+                  </div>
+                  <div>
+                    Last Occurrence: <i>{relativeTime(lastEpochMilliseconds)}</i>
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+          <div>{e.message}</div>
+          <div>
+            <JobManifestPodLogs
+              account={this.props.manifest.account}
+              location={namespace}
+              podNamesProviders={[new JobEventBasedPodNameProvider(this.props.manifest, e)]}
+              linkName="Console Output (Raw)"
+            />
+          </div>
+          {i !== events.length - 1 && <br />}
+        </div>
+      );
+    });
+  }
+}

package/src/pipelines/stages/deployManifest/manifestStatus/ManifestStatus.less

@@ -0,0 +1,24 @@
+dl.manifest-status {
+  display: block;
+  margin: 0;
+
+  dt,
+  dd {
+    display: inline-block;
+  }
+
+  dt {
+    margin-right: 4px;
+  }
+}
+
+.manifest-support-links {
+  margin: 0 0 1em;
+  a {
+    margin-right: 2em;
+  }
+}
+
+.manifest-events {
+  margin: 0 0 2em;
+}

package/src/pipelines/stages/deployManifest/manifestStatus/ManifestStatus.tsx

@@ -0,0 +1,46 @@
+import { dump } from 'js-yaml';
+import React from 'react';
+
+import type { IManifest } from '@spinnaker/core';
+import { CopyToClipboard, ManifestYaml } from '@spinnaker/core';
+
+import { DeployManifestStatusPills } from './DeployStatusPills';
+import { ManifestDetailsLink } from './ManifestDetailsLink';
+import { ManifestEvents } from './ManifestEvents';
+
+import './ManifestStatus.less';
+
+export interface IManifestStatusProps {
+  account: string;
+  manifest: IManifest;
+}
+
+export function ManifestStatus({ account, manifest }: IManifestStatusProps) {
+  return (
+    <>
+      <dl className="manifest-status" key="manifest-status">
+        <dt>{manifest.manifest.kind}</dt>
+        <dd>
+          <CopyToClipboard
+            displayText={true}
+            text={manifest.manifest.metadata.name}
+            toolTip={`Copy ${manifest.manifest.metadata.name}`}
+          />
+          &nbsp;
+          <DeployManifestStatusPills manifest={manifest} />
+        </dd>
+      </dl>
+      <div className="manifest-support-links" key="manifest-support-links">
+        <ManifestYaml
+          linkName="YAML"
+          manifestText={dump(manifest.manifest)}
+          modalTitle={manifest.manifest.metadata.name}
+        />
+        <ManifestDetailsLink linkName="Details" manifest={manifest} accountId={account} />
+      </div>
+      <div className="manifest-events pad-left" key="manifest-events">
+        <ManifestEvents manifest={manifest} />
+      </div>
+    </>
+  );
+}

package/src/pipelines/stages/findArtifactsFromResource/FindArtifactsFromResourceConfig.tsx

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

package/src/pipelines/stages/findArtifactsFromResource/FindArtifactsFromResourceStageForm.tsx

@@ -0,0 +1,37 @@
+import React from 'react';
+
+import type { IFormikStageConfigInjectedProps } from '@spinnaker/core';
+
+import type { IManifestSelector } from '../../../manifest/selector/IManifestSelector';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+import { ManifestSelector } from '../../../manifest/selector/ManifestSelector';
+
+interface IFindArtifactsFromResourceStageConfigFormProps {
+  stageFieldUpdated: () => void;
+}
+
+export function FindArtifactsFromResourceStageForm({
+  application,
+  formik,
+  stageFieldUpdated,
+}: IFindArtifactsFromResourceStageConfigFormProps & IFormikStageConfigInjectedProps) {
+  const stage = formik.values;
+
+  const onManifestSelectorChange = () => {
+    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}
+      />
+    </div>
+  );
+}

package/src/pipelines/stages/findArtifactsFromResource/findArtifactsFromResourceStage.ts

@@ -0,0 +1,21 @@
+import type { IStage } from '@spinnaker/core';
+import { ExecutionArtifactTab, ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { FindArtifactsFromResourceConfig } from './FindArtifactsFromResourceConfig';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+const STAGE_NAME = 'Find Artifacts From Resource (Manifest)';
+const STAGE_KEY = 'findArtifactsFromResource';
+
+Registry.pipeline.registerStage({
+  label: STAGE_NAME,
+  description: 'Finds artifacts from a Kubernetes resource.',
+  key: STAGE_KEY,
+  cloudProvider: 'kubernetes',
+  component: FindArtifactsFromResourceConfig,
+  executionDetailsSections: [ExecutionDetailsTasks, ExecutionArtifactTab],
+  producesArtifacts: true,
+  validators: manifestSelectorValidators(STAGE_NAME),
+  accountExtractor: (stage: IStage): string[] => (stage.context.account ? [stage.context.account] : []),
+  configAccountExtractor: (stage: any): string[] => (stage.account ? [stage.account] : []),
+});

package/src/pipelines/stages/index.ts

@@ -0,0 +1,8 @@
+export * from './deleteManifest/deleteManifestStage';
+export * from './deployManifest/deployManifestStage';
+export * from './findArtifactsFromResource/findArtifactsFromResourceStage';
+export * from './patchManifest/patchManifestStage';
+export * from './rolloutRestartManifest/rolloutRestartManifestStage';
+export * from './runJob/runJobStage';
+export * from './undoRolloutManifest/undoRolloutManifestStage';
+export * from './scaleManifest/scaleManifestStage';