@spinnaker/kubernetes 0.0.0-2025.1-0

package/src/manifest/delete/deleteOptionsForm.component.ts

@@ -0,0 +1,52 @@
+import type { IComponentOptions, IController } from 'angular';
+import { module } from 'angular';
+
+import type { IDeleteOptions } from './delete.controller';
+
+class KubernetesDeleteManifestOptionsFormCtrl implements IController {
+  public options: IDeleteOptions;
+}
+
+const kubernetesDeletManifestOptionsFormComponent: IComponentOptions = {
+  bindings: { options: '=' },
+  controller: KubernetesDeleteManifestOptionsFormCtrl,
+  controllerAs: 'ctrl',
+  template: `
+    <div class="form-horizontal">
+      <div class="form-group form-inline">
+        <div class="col-md-3 sm-label-right">
+          Cascading
+          <help-field key="kubernetes.manifest.delete.cascading"></help-field>
+        </div>
+        <div class="col-md-3">
+          <div class="input-group">
+            <input type="checkbox"
+                  ng-model="ctrl.options.cascading"/>
+          </div>
+        </div>
+      </div>
+      <div class="form-group form-inline">
+        <div class="col-md-3 sm-label-right">
+          Grace Period
+          <help-field key="kubernetes.manifest.delete.gracePeriod"></help-field>
+        </div>
+        <div class="col-md-4">
+          <div class="input-group">
+            <input type="number"
+                  class="form-control input-sm highlight-pristine"
+                  ng-model="ctrl.options.gracePeriodSeconds"
+                  min="0"/>
+            <span class="input-group-addon">second<span ng-if="ctrl.options.gracePeriodSeconds !== 1">s</span></span>
+          </div>
+        </div>
+      </div>
+    </div>
+  `,
+};
+
+export const KUBERNETES_DELETE_MANIFEST_OPTIONS_FORM =
+  'spinnaker.kubernetes.v2.kubernetes.manifest.delete.options.component';
+module(KUBERNETES_DELETE_MANIFEST_OPTIONS_FORM, []).component(
+  'kubernetesDeleteManifestOptionsForm',
+  kubernetesDeletManifestOptionsFormComponent,
+);

package/src/manifest/editor/json/JsonEditor.tsx

@@ -0,0 +1,56 @@
+import 'brace/mode/json';
+import 'brace/theme/textmate';
+import { $log } from 'ngimport';
+import React from 'react';
+import AceEditor from 'react-ace';
+
+export interface IJsonEditorProps {
+  value: string;
+  onChange(raw: string, obj: any): void;
+}
+
+export const JSON_EDITOR_TAB_SIZE = 2;
+
+export class JsonEditor extends React.Component<IJsonEditorProps> {
+  private handleChange = (raw: string) => {
+    try {
+      const obj = JSON.parse(raw);
+      this.props.onChange
+        ? this.props.onChange(raw, obj)
+        : $log.warn('No `onChange` handler provided for JSON editor.');
+    } catch (e) {
+      this.props.onChange
+        ? this.props.onChange(raw, null)
+        : $log.warn('No `onChange` handler provided for JSON editor.');
+      $log.warn(`Error loading JSON from string ${raw}: `, e);
+    }
+  };
+
+  public render = () => {
+    return (
+      <AceEditor
+        mode="json"
+        theme="textmate"
+        name="json-editor"
+        style={{ width: 'inherit' }}
+        onChange={this.handleChange}
+        fontSize={12}
+        showGutter={true}
+        cursorStart={0}
+        showPrintMargin={false}
+        minLines={50}
+        maxLines={100}
+        highlightActiveLine={true}
+        value={this.props.value || undefined}
+        setOptions={{
+          firstLineNumber: 1,
+          tabSize: JSON_EDITOR_TAB_SIZE,
+          showLineNumbers: false,
+          showFoldWidgets: false,
+        }}
+        editorProps={{ $blockScrolling: Infinity }}
+        className="ace-editor"
+      />
+    );
+  };
+}

package/src/manifest/editor/json/jsonEditor.component.ts

@@ -0,0 +1,12 @@
+import { module } from 'angular';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { JsonEditor } from './JsonEditor';
+
+export const JSON_EDITOR_COMPONENT = 'spinnaker.kubernetes.jsonEditor.component';
+module(JSON_EDITOR_COMPONENT, []).component(
+  'jsonEditor',
+  react2angular(withErrorBoundary(JsonEditor, 'jsonEditor'), ['onChange', 'value']),
+);

package/src/manifest/index.ts

@@ -0,0 +1,10 @@
+export * from './manifest.service';
+export * from './manifestCommandBuilder.service';
+export * from './IManifestCoordinates';
+export * from './artifact/ManifestArtifact';
+export * from './delete/delete.controller';
+export * from './rollout/pause.controller';
+export * from './rollout/undo.controller';
+export * from './scale/scale.controller';
+export * from './status/condition.component';
+export * from './status/status.component';

package/src/manifest/manifest.service.ts

@@ -0,0 +1,90 @@
+import type { Application, IManifest } from '@spinnaker/core';
+import { ManifestReader } from '@spinnaker/core';
+
+export interface IStageManifest {
+  kind: string;
+  apiVersion: string;
+  metadata: {
+    namespace: string;
+    name: string;
+  };
+}
+
+export interface IManifestParams {
+  account: string;
+  location: string;
+  name: string;
+}
+
+export type IManifestCallback = (manifest: IManifest) => void;
+
+export class KubernetesManifestService {
+  public static subscribe(app: Application, params: IManifestParams, fn: IManifestCallback): () => void {
+    KubernetesManifestService.updateManifest(params, fn);
+    return app.onRefresh(null, () => KubernetesManifestService.updateManifest(params, fn));
+  }
+
+  private static updateManifest(params: IManifestParams, fn: IManifestCallback) {
+    ManifestReader.getManifest(params.account, params.location, params.name).then((manifest) => fn(manifest));
+  }
+
+  public static manifestIdentifier(manifest: IStageManifest) {
+    const kind = manifest.kind.toLowerCase();
+    // manifest.metadata.namespace doesn't exist if it's a namespace being deployed
+    const namespace = (manifest.metadata.namespace || '_').toLowerCase();
+    const name = manifest.metadata.name.toLowerCase();
+    const apiVersion = (manifest.apiVersion || '_').toLowerCase();
+    // assuming this identifier is opaque and not parsed anywhere. Including the
+    // apiVersion will prevent collisions with CRD kinds without having any visible
+    // effect elsewhere
+    return `${namespace} ${kind} ${apiVersion} ${name}`;
+  }
+
+  public static stageManifestToManifestParams(manifest: IStageManifest, account: string): IManifestParams {
+    return {
+      account,
+      name: KubernetesManifestService.scopedKind(manifest) + ' ' + manifest.metadata.name,
+      location: manifest.metadata.namespace == null ? '_' : manifest.metadata.namespace,
+    };
+  }
+
+  private static apiGroup(manifest: IStageManifest): string {
+    const parts = (manifest.apiVersion || '_').split('/');
+    if (parts.length < 2) {
+      return '';
+    }
+    return parts[0];
+  }
+
+  private static isCRDGroup(manifest: IStageManifest): boolean {
+    return !KubernetesManifestService.BUILT_IN_GROUPS.includes(KubernetesManifestService.apiGroup(manifest));
+  }
+
+  private static scopedKind(manifest: IStageManifest): string {
+    if (KubernetesManifestService.isCRDGroup(manifest)) {
+      return manifest.kind + '.' + KubernetesManifestService.apiGroup(manifest);
+    }
+
+    return manifest.kind;
+  }
+
+  // from https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.12/
+  private static readonly BUILT_IN_GROUPS = [
+    '',
+    'core',
+    'batch',
+    'apps',
+    'extensions',
+    'storage.k8s.io',
+    'apiextensions.k8s.io',
+    'apiregistration.k8s.io',
+    'policy',
+    'scheduling.k8s.io',
+    'settings.k8s.io',
+    'authorization.k8s.io',
+    'authentication.k8s.io',
+    'rbac.authorization.k8s.io',
+    'certifcates.k8s.io',
+    'networking.k8s.io',
+  ];
+}

package/src/manifest/manifestCommandBuilder.service.ts

@@ -0,0 +1,126 @@
+import { load } from 'js-yaml';
+import { cloneDeep, has } from 'lodash';
+import { $q } from 'ngimport';
+
+import type { Application, IAccountDetails, IArtifactAccount, IMoniker } from '@spinnaker/core';
+import { AccountService } from '@spinnaker/core';
+
+import { ManifestSource } from './ManifestSource';
+
+const LAST_APPLIED_CONFIGURATION = 'kubectl.kubernetes.io/last-applied-configuration';
+
+export interface IKubernetesManifestCommandData {
+  command: IKubernetesManifestCommand;
+  metadata: IKubernetesManifestCommandMetadata;
+}
+
+export interface IKubernetesManifestCommand {
+  account: string;
+  cloudProvider: string;
+  manifest: any; // deprecated
+  manifests: any[];
+  relationships: IKubernetesManifestSpinnakerRelationships;
+  moniker: IMoniker;
+  manifestArtifactId?: string;
+  manifestArtifactAccount?: string;
+  source: ManifestSource;
+  versioned?: boolean;
+}
+
+export interface IKubernetesManifestCommandMetadata {
+  backingData: any;
+}
+
+export interface IKubernetesManifestSpinnakerRelationships {
+  loadBalancers?: string[];
+  securityGroups?: string[];
+}
+
+export class KubernetesManifestCommandBuilder {
+  // TODO(lwander) add explanatory error messages
+  public static manifestCommandIsValid(command: IKubernetesManifestCommand): boolean {
+    if (!command.moniker) {
+      return false;
+    }
+
+    if (!command.moniker.app) {
+      return false;
+    }
+
+    return true;
+  }
+
+  public static copyAndCleanCommand(input: IKubernetesManifestCommand): IKubernetesManifestCommand {
+    const command = cloneDeep(input);
+    return command;
+  }
+
+  public static buildNewManifestCommand(
+    app: Application,
+    sourceManifest?: any,
+    sourceMoniker?: IMoniker,
+    sourceAccount?: string,
+  ): PromiseLike<IKubernetesManifestCommandData> {
+    if (sourceManifest != null && has(sourceManifest, ['metadata', 'annotations', LAST_APPLIED_CONFIGURATION])) {
+      sourceManifest = load(sourceManifest.metadata.annotations[LAST_APPLIED_CONFIGURATION]);
+    }
+
+    const dataToFetch = {
+      accounts: AccountService.getAllAccountDetailsForProvider('kubernetes'),
+      artifactAccounts: AccountService.getArtifactAccounts(),
+    };
+
+    // TODO(dpeach): if no callers of this method are Angular controllers,
+    // $q.all may be safely replaced with Promise.all.
+    return $q
+      .all(dataToFetch)
+      .then((backingData: { accounts: IAccountDetails[]; artifactAccounts: IArtifactAccount[] }) => {
+        const { accounts, artifactAccounts } = backingData;
+
+        const account = accounts.some((a) => a.name === sourceAccount)
+          ? accounts.find((a) => a.name === sourceAccount).name
+          : accounts.length
+          ? accounts[0].name
+          : null;
+
+        let manifestArtifactAccount: string = null;
+        const [artifactAccountData] = artifactAccounts;
+        if (artifactAccountData) {
+          manifestArtifactAccount = artifactAccountData.name;
+        }
+
+        const cloudProvider = 'kubernetes';
+        const moniker = sourceMoniker || {
+          app: app.name,
+        };
+
+        const relationships = {
+          loadBalancers: [] as string[],
+          securityGroups: [] as string[],
+        };
+
+        const versioned: any = null;
+
+        return {
+          command: {
+            cloudProvider,
+            manifest: null,
+            manifests: Array.isArray(sourceManifest)
+              ? sourceManifest
+              : sourceManifest != null
+              ? [sourceManifest]
+              : null,
+            relationships,
+            moniker,
+            account,
+            versioned,
+            manifestArtifactAccount,
+            source: ManifestSource.TEXT,
+          },
+          metadata: {
+            backingData,
+          },
+        } as IKubernetesManifestCommandData;
+      });
+  }
+}

package/src/manifest/manifestEvents.component.ts

@@ -0,0 +1,12 @@
+import { module } from 'angular';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { ManifestEvents } from '../pipelines/stages/deployManifest/manifestStatus/ManifestEvents';
+
+export const KUBERNETES_MANIFEST_EVENTS = 'spinnaker.kubernetes.v2.manifest.events';
+module(KUBERNETES_MANIFEST_EVENTS, []).component(
+  'kubernetesManifestEvents',
+  react2angular(withErrorBoundary(ManifestEvents, 'kubernetesManifestEvents'), ['manifest']),
+);

package/src/manifest/manifestImageDetails.component.ts

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

package/src/manifest/manifestLabels.component.ts

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

package/src/manifest/manifestLabels.less

@@ -0,0 +1,3 @@
+.manifest-label {
+  margin: 2px;
+}

package/src/manifest/manifestQos.component.ts

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

package/src/manifest/manifestResources.component.ts

@@ -0,0 +1,12 @@
+import { module } from 'angular';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { ManifestResources } from './ManifestResources';
+
+export const KUBERNETES_MANIFEST_RESOURCES = 'spinnaker.kubernetes.v2.manifest.resources';
+module(KUBERNETES_MANIFEST_RESOURCES, []).component(
+  'kubernetesManifestResources',
+  react2angular(withErrorBoundary(ManifestResources, 'kubernetesManifestResources'), ['manifest', 'metrics']),
+);

package/src/manifest/rollout/RollingRestart.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+
+import type { Application } from '@spinnaker/core';
+import { ConfirmationModalService, ManifestWriter } from '@spinnaker/core';
+
+import type { IKubernetesServerGroupManager } from '../../interfaces';
+
+interface IRollingRestartProps {
+  application: Application;
+  serverGroupManager: IKubernetesServerGroupManager;
+}
+
+interface IRollingRestartParameters {
+  account: string;
+  cloudProvider: string;
+  location: string;
+  manifestName: string;
+}
+
+export function RollingRestart({ application, serverGroupManager }: IRollingRestartProps) {
+  function rollingRestart() {
+    const rollingRestartParameters: IRollingRestartParameters = {
+      account: serverGroupManager.account,
+      cloudProvider: 'kubernetes',
+      location: serverGroupManager.namespace,
+      manifestName: serverGroupManager.name,
+    };
+    ConfirmationModalService.confirm({
+      account: serverGroupManager.account,
+      askForReason: true,
+      header: `Initiate rolling restart of ${serverGroupManager.name}`,
+      submitMethod: () => {
+        return ManifestWriter.rollingRestartManifest(rollingRestartParameters, application);
+      },
+      taskMonitorConfig: {
+        application,
+        title: `Rolling restart of ${serverGroupManager.name}`,
+      },
+    });
+  }
+  return (
+    <li>
+      <a onClick={rollingRestart}>Rolling Restart</a>
+    </li>
+  );
+}

package/src/manifest/rollout/pause.controller.ts

@@ -0,0 +1,66 @@
+import type { IController } from 'angular';
+import { copy, module } from 'angular';
+import type { IModalServiceInstance } from 'angular-ui-bootstrap';
+
+import type { Application } from '@spinnaker/core';
+import { ManifestWriter, TaskMonitor } from '@spinnaker/core';
+import type { IManifestCoordinates } from '../IManifestCoordinates';
+
+interface IPauseRolloutCommand {
+  manifestName: string;
+  location: string;
+  account: string;
+  reason: string;
+}
+
+class KubernetesManifestPauseRolloutController implements IController {
+  public taskMonitor: TaskMonitor;
+  public command: IPauseRolloutCommand;
+  public verification = {
+    verified: false,
+  };
+
+  public static $inject = ['coordinates', '$uibModalInstance', 'application'];
+  constructor(
+    coordinates: IManifestCoordinates,
+    private $uibModalInstance: IModalServiceInstance,
+    private application: Application,
+  ) {
+    this.taskMonitor = new TaskMonitor({
+      title: `Pause rollout of ${coordinates.name} in ${coordinates.namespace}`,
+      application,
+      modalInstance: $uibModalInstance,
+    });
+
+    this.command = {
+      manifestName: coordinates.name,
+      location: coordinates.namespace,
+      account: coordinates.account,
+      reason: null,
+    };
+  }
+
+  public isValid(): boolean {
+    return this.verification.verified;
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public pauseRollout(): void {
+    this.taskMonitor.submit(() => {
+      const payload = copy(this.command) as any;
+      payload.cloudProvider = 'kubernetes';
+
+      return ManifestWriter.pauseRolloutManifest(payload, this.application);
+    });
+  }
+}
+
+export const KUBERNETES_MANIFEST_PAUSE_ROLLOUT_CTRL = 'spinnaker.kubernetes.v2.manifest.pauseRollout.controller';
+
+module(KUBERNETES_MANIFEST_PAUSE_ROLLOUT_CTRL, []).controller(
+  'kubernetesV2ManifestPauseRolloutCtrl',
+  KubernetesManifestPauseRolloutController,
+);

package/src/manifest/rollout/pause.html

@@ -0,0 +1,28 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="ctrl.taskMonitor"></task-monitor>
+  <form role="form" name="pauseRolloutForm">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">
+        Pause rollout of {{ctrl.command.manifestName | robotToHuman}} in {{ctrl.command.location}}
+      </h4>
+    </div>
+    <div class="modal-body confirmation-modal">
+      <task-reason command="ctrl.command"></task-reason>
+    </div>
+    <div class="modal-footer">
+      <user-verification account="ctrl.command.account" verification="ctrl.verification"></user-verification>
+      <button type="submit" ng-click="ctrl.pauseRollout()" style="display: none"></button>
+      <!-- Allows form submission via enter keypress-->
+      <button class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+      <button
+        type="submit"
+        class="btn btn-primary"
+        ng-click="ctrl.pauseRollout()"
+        ng-disabled="!ctrl.isValid() || !pauseRolloutForm.$valid"
+      >
+        Submit
+      </button>
+    </div>
+  </form>
+</div>

package/src/manifest/rollout/resume.controller.ts

@@ -0,0 +1,66 @@
+import type { IController } from 'angular';
+import { copy, module } from 'angular';
+import type { IModalServiceInstance } from 'angular-ui-bootstrap';
+
+import type { Application } from '@spinnaker/core';
+import { ManifestWriter, TaskMonitor } from '@spinnaker/core';
+import type { IManifestCoordinates } from '../IManifestCoordinates';
+
+interface IResumeRolloutCommand {
+  manifestName: string;
+  location: string;
+  account: string;
+  reason: string;
+}
+
+class KubernetesManifestResumeRolloutController implements IController {
+  public taskMonitor: TaskMonitor;
+  public command: IResumeRolloutCommand;
+  public verification = {
+    verified: false,
+  };
+
+  public static $inject = ['coordinates', '$uibModalInstance', 'application'];
+  constructor(
+    coordinates: IManifestCoordinates,
+    private $uibModalInstance: IModalServiceInstance,
+    private application: Application,
+  ) {
+    this.taskMonitor = new TaskMonitor({
+      title: `Resume rollout of ${coordinates.name} in ${coordinates.namespace}`,
+      application,
+      modalInstance: $uibModalInstance,
+    });
+
+    this.command = {
+      manifestName: coordinates.name,
+      location: coordinates.namespace,
+      account: coordinates.account,
+      reason: null,
+    };
+  }
+
+  public isValid(): boolean {
+    return this.verification.verified;
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public resumeRollout(): void {
+    this.taskMonitor.submit(() => {
+      const payload = copy(this.command) as any;
+      payload.cloudProvider = 'kubernetes';
+
+      return ManifestWriter.resumeRolloutManifest(payload, this.application);
+    });
+  }
+}
+
+export const KUBERNETES_MANIFEST_RESUME_ROLLOUT_CTRL = 'spinnaker.kubernetes.v2.manifest.resumeRollout.controller';
+
+module(KUBERNETES_MANIFEST_RESUME_ROLLOUT_CTRL, []).controller(
+  'kubernetesV2ManifestResumeRolloutCtrl',
+  KubernetesManifestResumeRolloutController,
+);

package/src/manifest/rollout/resume.html

@@ -0,0 +1,28 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="ctrl.taskMonitor"></task-monitor>
+  <form role="form" name="resumeRolloutForm">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">
+        Resume rollout of {{ctrl.command.manifestName | robotToHuman}} in {{ctrl.command.location}}
+      </h4>
+    </div>
+    <div class="modal-body confirmation-modal">
+      <task-reason command="ctrl.command"></task-reason>
+    </div>
+    <div class="modal-footer">
+      <user-verification account="ctrl.command.account" verification="ctrl.verification"></user-verification>
+      <button type="submit" ng-click="ctrl.resumeRollout()" style="display: none"></button>
+      <!-- Allows form submission via enter keypress-->
+      <button class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+      <button
+        type="submit"
+        class="btn btn-primary"
+        ng-click="ctrl.resumeRollout()"
+        ng-disabled="!ctrl.isValid() || !resumeRolloutForm.$valid"
+      >
+        Submit
+      </button>
+    </div>
+  </form>
+</div>