@spinnaker/kubernetes 0.0.0-main-2

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,54 @@
+import { module } from 'angular';
+import React from 'react';
+import { react2angular } from 'react2angular';
+
+import type { Application } from '@spinnaker/core';
+import { ConfirmationModalService, ManifestWriter, withErrorBoundary } from '@spinnaker/core';
+
+import type { IKubernetesServerGroupManager } from '../../interfaces';
+
+interface IRollingRestartProps {
+  application: Application;
+  serverGroupManager: IKubernetesServerGroupManager;
+}
+
+interface IRollingRestartParameters {
+  account: string;
+  cloudProvider: string;
+  location: string;
+  manifestName: string;
+}
+
+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>
+  );
+}
+
+export const KUBERNETES_ROLLING_RESTART = 'spinnaker.kubernetes.v2.rolling.restart';
+module(KUBERNETES_ROLLING_RESTART, []).component(
+  'kubernetesRollingRestart',
+  react2angular(withErrorBoundary(RollingRestart, 'kubernetesRollingRestart'), ['application', 'serverGroupManager']),
+);

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>

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

@@ -0,0 +1,74 @@
+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 IUndoRolloutCommand {
+  manifestName: string;
+  location: string;
+  account: string;
+  reason: string;
+  revision: number;
+}
+
+interface IRolloutRevision {
+  label: string;
+  revision: number;
+}
+
+class KubernetesManifestUndoRolloutController implements IController {
+  public taskMonitor: TaskMonitor;
+  public command: IUndoRolloutCommand;
+  public verification = {
+    verified: false,
+  };
+
+  public static $inject = ['coordinates', 'revisions', '$uibModalInstance', 'application'];
+  constructor(
+    coordinates: IManifestCoordinates,
+    public revisions: IRolloutRevision[],
+    private $uibModalInstance: IModalServiceInstance,
+    private application: Application,
+  ) {
+    this.taskMonitor = new TaskMonitor({
+      title: `Undo rollout of ${coordinates.name} in ${coordinates.namespace}`,
+      application,
+      modalInstance: $uibModalInstance,
+    });
+
+    this.command = {
+      manifestName: coordinates.name,
+      location: coordinates.namespace,
+      account: coordinates.account,
+      reason: null,
+      revision: null,
+    };
+  }
+
+  public isValid(): boolean {
+    return this.verification.verified;
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public undoRollout(): void {
+    this.taskMonitor.submit(() => {
+      const payload = copy(this.command) as any;
+      payload.cloudProvider = 'kubernetes';
+
+      return ManifestWriter.undoRolloutManifest(payload, this.application);
+    });
+  }
+}
+
+export const KUBERNETES_MANIFEST_UNDO_ROLLOUT_CTRL = 'spinnaker.kubernetes.v2.manifest.undoRollout.controller';
+
+module(KUBERNETES_MANIFEST_UNDO_ROLLOUT_CTRL, []).controller(
+  'kubernetesV2ManifestUndoRolloutCtrl',
+  KubernetesManifestUndoRolloutController,
+);

package/src/manifest/rollout/undo.html

@@ -0,0 +1,44 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="ctrl.taskMonitor"></task-monitor>
+  <form role="form" name="undoRolloutForm">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">
+        Undo rollout of {{ctrl.command.manifestName | robotToHuman}} in {{ctrl.command.location}}
+      </h4>
+    </div>
+    <div class="modal-body confirmation-modal">
+      <div class="form-horizontal">
+        <div class="form-group form-inline">
+          <div class="col-md-3 sm-label-right">Revision</div>
+          <div class="col-md-7">
+            <select style="width: 100%" class="form-control input-sm" ng-model="ctrl.command.revision">
+              <option
+                ng-repeat="revision in ctrl.revisions"
+                value="{{revision.revision}}"
+                ng-selected="ctrl.command.revisions === revision.revision"
+              >
+                {{revision.label}}
+              </option>
+            </select>
+          </div>
+        </div>
+      </div>
+      <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.undoRollout()" 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.undoRollout()"
+        ng-disabled="!ctrl.isValid() || !undoRolloutForm.$valid"
+      >
+        Submit
+      </button>
+    </div>
+  </form>
+</div>

package/src/manifest/scale/ScaleSettingsForm.tsx

@@ -0,0 +1,43 @@
+import React, { useState } from 'react';
+import { NumberInput, StageConfigField } from '@spinnaker/core';
+import type { IScaleCommand } from './scale.controller';
+
+export interface IScaleSettingsFormProps {
+  options: IScaleCommand;
+  onChange(options: IScaleCommand): void;
+}
+
+export interface IScaleSettingsFormState {
+  options: IScaleCommand;
+}
+
+export function ScaleSettingsForm({ options, onChange }: IScaleSettingsFormProps) {
+  const [state, setState] = useState<IScaleSettingsFormState>({
+    options: options,
+  });
+
+  const updateReplicas = (newReplicas: number) => {
+    state.options.replicas = newReplicas;
+    if (onChange) {
+      onChange(state.options);
+    }
+    setState({ options: state.options });
+  };
+
+  return (
+    <div className="form-horizontal">
+      <StageConfigField label="Replicas" fieldColumns={4} groupClassName="form-group form-inline">
+        <div className="input-group">
+          <NumberInput
+            inputClassName="input-sm highlight-pristine"
+            onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
+              updateReplicas(e.target.valueAsNumber);
+            }}
+            value={options.replicas}
+            min={0}
+          />
+        </div>
+      </StageConfigField>
+    </div>
+  );
+}

package/src/manifest/scale/scale.controller.ts

@@ -0,0 +1,75 @@
+import type { IController, IScope } 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';
+import { KUBERNETES_SCALE_MANIFEST_SETTINGS_FORM } from './scaleSettingsForm.component';
+
+export interface IScaleCommand {
+  manifestName: string;
+  location: string;
+  account: string;
+  reason: string;
+  replicas: number;
+}
+
+class KubernetesManifestScaleController implements IController {
+  public taskMonitor: TaskMonitor;
+  public verification = {
+    verified: false,
+  };
+
+  public static $inject = ['$scope', 'coordinates', 'currentReplicas', '$uibModalInstance', 'application'];
+  constructor(
+    private $scope: IScope,
+    coordinates: IManifestCoordinates,
+    currentReplicas: number,
+    private $uibModalInstance: IModalServiceInstance,
+    private application: Application,
+  ) {
+    this.taskMonitor = new TaskMonitor({
+      title: `Scaling ${coordinates.name} in ${coordinates.namespace}`,
+      application,
+      modalInstance: $uibModalInstance,
+    });
+
+    this.$scope.command = {
+      manifestName: coordinates.name,
+      location: coordinates.namespace,
+      account: coordinates.account,
+      reason: null,
+      replicas: currentReplicas,
+    };
+
+    // used by react components to update command fields in parent (angular) scope
+    this.$scope.onChange = () => {
+      this.$scope.$applyAsync();
+    };
+  }
+
+  public isValid(): boolean {
+    return this.verification.verified;
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public scale(): void {
+    this.taskMonitor.submit(() => {
+      const payload = copy(this.$scope.command) as any;
+      payload.cloudProvider = 'kubernetes';
+
+      return ManifestWriter.scaleManifest(payload, this.application);
+    });
+  }
+}
+
+export const KUBERNETES_MANIFEST_SCALE_CTRL = 'spinnaker.kubernetes.v2.manifest.scale.controller';
+
+module(KUBERNETES_MANIFEST_SCALE_CTRL, [KUBERNETES_SCALE_MANIFEST_SETTINGS_FORM]).controller(
+  'kubernetesV2ManifestScaleCtrl',
+  KubernetesManifestScaleController,
+);