@spinnaker/kubernetes 0.0.0-main-2

package/src/instance/details/details.controller.ts

@@ -0,0 +1,186 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController, IQService, IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalService } from 'angular-ui-bootstrap';
+import { flattenDeep } from 'lodash';
+
+import type { Application, ILoadBalancer, IManifest } from '@spinnaker/core';
+import { InstanceReader, ManifestReader, RecentHistoryService, SETTINGS } from '@spinnaker/core';
+
+import type { IKubernetesInstance } from '../../interfaces';
+import { KubernetesManifestCommandBuilder } from '../../manifest/manifestCommandBuilder.service';
+import { ManifestWizard } from '../../manifest/wizard/ManifestWizard';
+
+interface InstanceFromStateParams {
+  instanceId: string;
+}
+
+interface InstanceManager {
+  account: string;
+  region: string;
+  category: string; // e.g., serverGroup, loadBalancer.
+  name: string; // Parent resource name, not instance name.
+  instances: IKubernetesInstance[];
+}
+
+interface IConsoleOutputInstance {
+  account: string;
+  region: string;
+  id: string;
+  provider: string;
+}
+
+interface InstanceIdentifier {
+  account: string;
+  id: string;
+  name: string;
+  namespace: string;
+}
+
+class KubernetesInstanceDetailsController implements IController {
+  public state = { loading: true };
+  public instance: IKubernetesInstance;
+  public manifest: IManifest;
+  public consoleOutputInstance: IConsoleOutputInstance;
+  public environment: string;
+
+  public static $inject = ['instance', '$uibModal', '$q', '$scope', 'app', '$state'];
+  constructor(
+    instance: InstanceFromStateParams,
+    private $uibModal: IModalService,
+    private $q: IQService,
+    private $scope: IScope,
+    private app: Application,
+    private $state: StateService,
+  ) {
+    this.app
+      .ready()
+      .then(() => {
+        this.extractInstance(instance);
+        this.app.onRefresh(this.$scope, () => this.extractInstance(instance));
+        this.$scope.isDisabled = !SETTINGS.kubernetesAdHocInfraWritesEnabled;
+      })
+      .catch(() => this.autoClose());
+  }
+
+  public deleteInstance(): void {
+    this.$uibModal.open({
+      templateUrl: require('../../manifest/delete/delete.html'),
+      controller: 'kubernetesV2ManifestDeleteCtrl',
+      controllerAs: 'ctrl',
+      resolve: {
+        coordinates: {
+          name: this.instance.name,
+          namespace: this.instance.namespace,
+          account: this.instance.account,
+        },
+        application: this.app,
+        manifestController: (): string => null,
+      },
+    });
+  }
+
+  public editInstance(): void {
+    KubernetesManifestCommandBuilder.buildNewManifestCommand(
+      this.app,
+      this.manifest.manifest,
+      this.instance.moniker,
+      this.instance.account,
+    ).then((builtCommand) => {
+      ManifestWizard.show({ title: 'Edit Manifest', application: this.app, command: builtCommand });
+    });
+  }
+
+  private extractInstance(instanceFromState: InstanceFromStateParams): void {
+    const instanceId = this.retrieveInstance(instanceFromState);
+    if (!instanceId) {
+      return this.autoClose();
+    }
+    this.$q
+      .all([
+        this.fetchInstance(instanceId).then((instance: IKubernetesInstance) => {
+          this.instance = instance;
+          this.consoleOutputInstance = {
+            account: instance.account,
+            region: instance.zone,
+            id: instance.humanReadableName,
+            provider: instance.provider,
+          };
+        }),
+        ManifestReader.getManifest(instanceId.account, instanceId.namespace, instanceId.name).then(
+          (manifest: IManifest) => {
+            this.manifest = manifest;
+          },
+        ),
+      ])
+      .then(() => {
+        this.state.loading = false;
+      });
+  }
+
+  private fetchInstance(instance: InstanceIdentifier): PromiseLike<IKubernetesInstance> {
+    return InstanceReader.getInstanceDetails(instance.account, instance.namespace, instance.name).then(
+      (instanceDetails: IKubernetesInstance) => {
+        instanceDetails.id = instance.id;
+        instanceDetails.name = instance.name;
+        instanceDetails.provider = 'kubernetes';
+        return instanceDetails;
+      },
+    );
+  }
+
+  private retrieveInstance(instanceFromState: InstanceFromStateParams): InstanceIdentifier {
+    const instanceLocatorPredicate = (dataSource: InstanceManager) => {
+      return dataSource.instances.some((possibleMatch) => possibleMatch.id === instanceFromState.instanceId);
+    };
+
+    const dataSources: InstanceManager[] = flattenDeep([
+      this.app.getDataSource('serverGroups').data,
+      this.app.getDataSource('loadBalancers').data,
+      this.app.getDataSource('loadBalancers').data.map((loadBalancer: ILoadBalancer) => loadBalancer.serverGroups),
+    ]);
+
+    const instanceManager = dataSources.find(instanceLocatorPredicate);
+    if (!instanceManager) {
+      return null;
+    }
+    const recentHistoryExtraData: { [key: string]: string } = {
+      region: instanceManager.region,
+      account: instanceManager.account,
+    };
+
+    if (instanceManager.category === 'serverGroup') {
+      recentHistoryExtraData.serverGroup = instanceManager.name;
+    }
+
+    const instance = instanceManager.instances.find((i) => i.id === instanceFromState.instanceId);
+    if (!instance) {
+      return null;
+    }
+
+    RecentHistoryService.addExtraDataToLatest('instances', recentHistoryExtraData);
+
+    return {
+      id: instance.id,
+      name: instance.name,
+      namespace: instanceManager.region,
+      account: instanceManager.account,
+    };
+  }
+
+  private autoClose(): void {
+    if (this.$scope.$$destroyed) {
+      return;
+    } else {
+      this.$state.params.allowModalToStayOpen = true;
+      this.$state.go('^', null, { location: 'replace' });
+    }
+  }
+}
+
+export const KUBERNETES_INSTANCE_DETAILS_CTRL = 'spinnaker.kubernetes.instanceDetails.controller';
+
+module(KUBERNETES_INSTANCE_DETAILS_CTRL, []).controller(
+  'kubernetesV2InstanceDetailsCtrl',
+  KubernetesInstanceDetailsController,
+);

package/src/instance/details/details.html

@@ -0,0 +1,80 @@
+<div class="details-panel">
+  <div class="header">
+    <instance-details-header
+      cloud-provider="ctrl.instance.cloudProvider"
+      health-state="instance.healthState"
+      instance-id="ctrl.instance.displayName"
+      loading="ctrl.state.loading"
+      standalone="false"
+    ></instance-details-header>
+    <div class="actions" ng-if="!ctrl.state.loading">
+      <div class="dropdown" uib-dropdown dropdown-append-to-body>
+        <button type="button" class="btn btn-sm btn-primary dropdown-toggle" uib-dropdown-toggle ng-hide="isDisabled">
+          {{ctrl.instance.kind | robotToHuman}} Actions <span class="caret"></span>
+        </button>
+        <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+          <li>
+            <a href ng-click="ctrl.deleteInstance()">Delete</a>
+          </li>
+          <li>
+            <a href ng-click="ctrl.editInstance()">Edit</a>
+          </li>
+        </ul>
+      </div>
+    </div>
+  </div>
+
+  <div ng-if="!ctrl.state.loading" class="content">
+    <collapsible-section heading="Information" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt>Created</dt>
+        <dd>{{ctrl.instance.createdTime | timestamp}}</dd>
+        <dt>Account</dt>
+        <dd><account-tag account="ctrl.instance.account" pad="right"></account-tag></dd>
+        <dt>Namespace</dt>
+        <dd>{{ctrl.instance.namespace}}</dd>
+        <dt>Kind</dt>
+        <dd>{{ctrl.instance.kind}}</dd>
+        <dt>QOS Class</dt>
+        <dd><kubernetes-manifest-qos manifest="ctrl.manifest.manifest"></kubernetes-manifest-qos></dd>
+        <dt>Logs</dt>
+        <dd>
+          <console-output-link instance="ctrl.consoleOutputInstance" uses-multi-output="true"></console-output-link>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Status" expanded="true">
+      <ul ng-repeat="condition in ctrl.manifest.manifest.status.conditions">
+        <kubernetes-manifest-condition condition="condition"></kubernetes-manifest-condition>
+      </ul>
+    </collapsible-section>
+
+    <kubernetes-annotation-custom-sections
+      manifest="ctrl.manifest.manifest"
+      resource="ctrl.instance"
+    ></kubernetes-annotation-custom-sections>
+
+    <collapsible-section heading="Events" expanded="true">
+      <kubernetes-manifest-events manifest="ctrl.manifest"></kubernetes-manifest-events>
+    </collapsible-section>
+
+    <collapsible-section heading="Resources" expanded="true">
+      <kubernetes-manifest-resources
+        manifest="ctrl.manifest.manifest"
+        metrics="ctrl.manifest.metrics"
+      ></kubernetes-manifest-resources>
+    </collapsible-section>
+
+    <collapsible-section heading="Labels" expanded="true">
+      <kubernetes-manifest-labels manifest="ctrl.manifest.manifest"></kubernetes-manifest-labels>
+    </collapsible-section>
+
+    <instance-links
+      address="ctrl.instance.publicDnsName"
+      application="ctrl.app"
+      instance="ctrl.instance"
+      moniker="ctrl.instance.moniker"
+      environment="ctrl.environment"
+    ></instance-links>
+  </div>
+</div>

package/src/instance/index.ts

@@ -0,0 +1 @@
+export * from './details/details.controller';

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './infrastructure.types';

package/src/interfaces/infrastructure.types.ts

@@ -0,0 +1,35 @@
+import type {
+  IInstance,
+  ILoadBalancer,
+  IMoniker,
+  ISecurityGroupDetail,
+  IServerGroup,
+  IServerGroupManager,
+} from '@spinnaker/core';
+
+export interface IKubernetesResource {
+  apiVersion: string;
+  createdTime?: number;
+  displayName: string;
+  kind: string;
+  namespace: string;
+}
+
+export interface IKubernetesInstance extends IInstance, IKubernetesResource {
+  humanReadableName: string;
+  moniker: IMoniker;
+  publicDnsName?: string;
+}
+
+export interface IKubernetesLoadBalancer extends ILoadBalancer, IKubernetesResource {}
+
+export interface IKubernetesSecurityGroup extends ISecurityGroupDetail, IKubernetesResource {
+  account: string;
+  moniker: IMoniker;
+}
+
+export interface IKubernetesServerGroup extends IServerGroup, IKubernetesResource {
+  disabled: boolean;
+}
+
+export interface IKubernetesServerGroupManager extends IServerGroupManager, IKubernetesResource {}

package/src/kubernetes.module.ts

@@ -0,0 +1,144 @@
+import { module } from 'angular';
+
+import {
+  CloudProviderRegistry,
+  SETTINGS,
+  STAGE_ARTIFACT_SELECTOR_COMPONENT_REACT,
+  YAML_EDITOR_COMPONENT,
+} from '@spinnaker/core';
+
+import './help/kubernetes.help';
+import { KUBERNETES_INSTANCE_DETAILS_CTRL } from './instance/details/details.controller';
+import { KUBERNETES_LOAD_BALANCER_DETAILS_CTRL } from './loadBalancer/details/details.controller';
+import { KUBERNETES_LOAD_BALANCER_TRANSFORMER } from './loadBalancer/transformer';
+import kubernetesLogo from './logo/kubernetes.logo.svg';
+import { KUBERNETES_ANNOTATION_CUSTOM_SECTIONS } from './manifest/annotationCustomSections.component';
+import { KUBERNETES_MANIFEST_ARTIFACT } from './manifest/artifact/artifact.component';
+import { KUBERNETES_MANIFEST_DELETE_CTRL } from './manifest/delete/delete.controller';
+import { JSON_EDITOR_COMPONENT } from './manifest/editor/json/jsonEditor.component';
+import { KUBERNETES_MANIFEST_EVENTS } from './manifest/manifestEvents.component';
+import { KUBERNETES_MANIFEST_IMAGE_DETAILS } from './manifest/manifestImageDetails.component';
+import { KUBERNETES_MANIFEST_LABELS } from './manifest/manifestLabels.component';
+import { KUBERNETES_MANIFEST_QOS } from './manifest/manifestQos.component';
+import { KUBERNETES_MANIFEST_RESOURCES } from './manifest/manifestResources.component';
+import { KUBERNETES_ROLLING_RESTART } from './manifest/rollout/RollingRestart';
+import { KUBERNETES_MANIFEST_PAUSE_ROLLOUT_CTRL } from './manifest/rollout/pause.controller';
+import { KUBERNETES_MANIFEST_RESUME_ROLLOUT_CTRL } from './manifest/rollout/resume.controller';
+import { KUBERNETES_MANIFEST_UNDO_ROLLOUT_CTRL } from './manifest/rollout/undo.controller';
+import { KUBERNETES_MANIFEST_SCALE_CTRL } from './manifest/scale/scale.controller';
+import { KUBERNETES_MANIFEST_SELECTOR } from './manifest/selector/selector.component';
+import { KUBERNETES_MANIFEST_CONDITION } from './manifest/status/condition.component';
+import { KUBERNETES_MANIFEST_STATUS } from './manifest/status/status.component';
+import { ManifestWizard } from './manifest/wizard/ManifestWizard';
+import './pipelines/stages';
+import { KUBERNETES_DISABLE_MANIFEST_STAGE } from './pipelines/stages/traffic/disableManifest.stage';
+import { KUBERNETES_ENABLE_MANIFEST_STAGE } from './pipelines/stages/traffic/enableManifest.stage';
+import './pipelines/validation/manifestSelector.validator';
+import { KUBERNETS_RAW_RESOURCE_MODULE } from './rawResource';
+import { KUBERNETES_RESOURCE_STATES } from './resources/resources.state';
+import { KUBERNETES_SECURITY_GROUP_DETAILS_CTRL } from './securityGroup/details/details.controller';
+import { KubernetesSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { KUBERNETES_SECURITY_GROUP_TRANSFORMER } from './securityGroup/transformer';
+import { KUBERNETES_SERVER_GROUP_DETAILS_CTRL } from './serverGroup/details/details.controller';
+import { KUBERNETES_SERVER_GROUP_RESIZE_CTRL } from './serverGroup/details/resize/resize.controller';
+import { KUBERNETES_SERVER_GROUP_COMMAND_BUILDER } from './serverGroup/serverGroupCommandBuilder.service';
+import { KUBERNETES_SERVER_GROUP_TRANSFORMER } from './serverGroup/serverGroupTransformer.service';
+import { KUBERNETES_SERVER_GROUP_MANAGER_DETAILS_CTRL } from './serverGroupManager/details/details.controller';
+import './validation/applicationName.validator';
+
+import './logo/kubernetes.logo.less';
+
+export const KUBERNETES_MODULE = 'spinnaker.kubernetes';
+
+const requires = [
+  KUBERNETES_INSTANCE_DETAILS_CTRL,
+  KUBERNETES_LOAD_BALANCER_DETAILS_CTRL,
+  KUBERNETES_SECURITY_GROUP_DETAILS_CTRL,
+  KUBERNETES_SERVER_GROUP_COMMAND_BUILDER,
+  KUBERNETES_SERVER_GROUP_DETAILS_CTRL,
+  KUBERNETES_SERVER_GROUP_TRANSFORMER,
+  KUBERNETES_SERVER_GROUP_MANAGER_DETAILS_CTRL,
+  KUBERNETES_SERVER_GROUP_RESIZE_CTRL,
+  KUBERNETES_SERVER_GROUP_MANAGER_DETAILS_CTRL,
+  KUBERNETES_MANIFEST_DELETE_CTRL,
+  KUBERNETES_MANIFEST_SCALE_CTRL,
+  KUBERNETES_MANIFEST_UNDO_ROLLOUT_CTRL,
+  KUBERNETES_MANIFEST_PAUSE_ROLLOUT_CTRL,
+  KUBERNETES_MANIFEST_RESUME_ROLLOUT_CTRL,
+  KUBERNETES_MANIFEST_STATUS,
+  KUBERNETES_MANIFEST_CONDITION,
+  KUBERNETES_MANIFEST_ARTIFACT,
+  KUBERNETES_LOAD_BALANCER_TRANSFORMER,
+  KUBERNETES_SECURITY_GROUP_TRANSFORMER,
+  KUBERNETES_MANIFEST_SELECTOR,
+  KUBERNETES_MANIFEST_LABELS,
+  KUBERNETES_MANIFEST_EVENTS,
+  KUBERNETES_MANIFEST_RESOURCES,
+  KUBERNETES_MANIFEST_QOS,
+  KUBERNETES_ANNOTATION_CUSTOM_SECTIONS,
+  KUBERNETES_MANIFEST_IMAGE_DETAILS,
+  KUBERNETES_RESOURCE_STATES,
+  YAML_EDITOR_COMPONENT,
+  JSON_EDITOR_COMPONENT,
+  KUBERNETES_ENABLE_MANIFEST_STAGE,
+  KUBERNETES_DISABLE_MANIFEST_STAGE,
+  STAGE_ARTIFACT_SELECTOR_COMPONENT_REACT,
+  KUBERNETES_ROLLING_RESTART,
+];
+
+if (SETTINGS.feature.kubernetesRawResources) {
+  requires.push(KUBERNETS_RAW_RESOURCE_MODULE);
+}
+
+module(KUBERNETES_MODULE, requires).config(() => {
+  CloudProviderRegistry.registerProvider('kubernetes', {
+    name: 'Kubernetes',
+    adHocInfrastructureWritesEnabled: SETTINGS.kubernetesAdHocInfraWritesEnabled,
+    logo: {
+      path: kubernetesLogo,
+    },
+    serverGroup: {
+      CloneServerGroupModal: ManifestWizard,
+      commandBuilder: 'kubernetesV2ServerGroupCommandBuilder',
+      detailsController: 'kubernetesV2ServerGroupDetailsCtrl',
+      detailsTemplateUrl: require('./serverGroup/details/details.html'),
+      transformer: 'kubernetesV2ServerGroupTransformer',
+    },
+    serverGroupManager: {
+      detailsTemplateUrl: require('./serverGroupManager/details/details.html'),
+      detailsController: 'kubernetesV2ServerGroupManagerDetailsCtrl',
+    },
+    loadBalancer: {
+      CreateLoadBalancerModal: ManifestWizard,
+      detailsController: 'kubernetesV2LoadBalancerDetailsCtrl',
+      detailsTemplateUrl: require('./loadBalancer/details/details.html'),
+      transformer: 'kubernetesV2LoadBalancerTransformer',
+    },
+    securityGroup: {
+      reader: KubernetesSecurityGroupReader,
+      CreateSecurityGroupModal: ManifestWizard,
+      detailsController: 'kubernetesV2SecurityGroupDetailsCtrl',
+      detailsTemplateUrl: require('./securityGroup/details/details.html'),
+      transformer: 'kubernetesV2SecurityGroupTransformer',
+    },
+    instance: {
+      detailsController: 'kubernetesV2InstanceDetailsCtrl',
+      detailsTemplateUrl: require('./instance/details/details.html'),
+    },
+    unsupportedStageTypes: [
+      'deploy',
+      'destroyServerGroup',
+      'disableCluster',
+      'disableServerGroup',
+      'enableServerGroup',
+      'findImage',
+      'resizeServerGroup',
+      'rollbackCluster',
+      'runJob',
+      'scaleDown',
+      'scaleDownCluster',
+      'shrinkCluster',
+      'upsertLoadBalancers',
+    ],
+  });
+});

package/src/loadBalancer/details/details.controller.ts

@@ -0,0 +1,101 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController, IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalService } from 'angular-ui-bootstrap';
+
+import type { Application, ILoadBalancer, IManifest } from '@spinnaker/core';
+import { ManifestReader, SETTINGS } from '@spinnaker/core';
+
+import type { IKubernetesLoadBalancer } from '../../interfaces';
+import { KubernetesManifestCommandBuilder } from '../../manifest/manifestCommandBuilder.service';
+import { ManifestWizard } from '../../manifest/wizard/ManifestWizard';
+
+interface ILoadBalancerFromStateParams {
+  accountId: string;
+  region: string;
+  name: string;
+}
+
+class KubernetesLoadBalancerDetailsController implements IController {
+  public state = { loading: true };
+  public manifest: IManifest;
+  public loadBalancer: IKubernetesLoadBalancer;
+
+  public static $inject = ['$uibModal', '$state', '$scope', 'loadBalancer', 'app'];
+  constructor(
+    private $uibModal: IModalService,
+    private $state: StateService,
+    private $scope: IScope,
+    loadBalancer: ILoadBalancerFromStateParams,
+    private app: Application,
+  ) {
+    const dataSource = this.app.getDataSource('loadBalancers');
+    dataSource
+      .ready()
+      .then(() => {
+        this.extractLoadBalancer(loadBalancer);
+        this.$scope.isDisabled = !SETTINGS.kubernetesAdHocInfraWritesEnabled;
+        dataSource.onRefresh(this.$scope, () => this.extractLoadBalancer(loadBalancer));
+      })
+      .catch(() => this.autoClose());
+  }
+
+  public deleteLoadBalancer(): void {
+    this.$uibModal.open({
+      templateUrl: require('../../manifest/delete/delete.html'),
+      controller: 'kubernetesV2ManifestDeleteCtrl',
+      controllerAs: 'ctrl',
+      resolve: {
+        coordinates: {
+          name: this.loadBalancer.name,
+          namespace: this.loadBalancer.namespace,
+          account: this.loadBalancer.account,
+        },
+        application: this.app,
+        manifestController: (): string => null,
+      },
+    });
+  }
+
+  public editLoadBalancer(): void {
+    KubernetesManifestCommandBuilder.buildNewManifestCommand(
+      this.app,
+      this.manifest.manifest,
+      this.loadBalancer.moniker,
+      this.loadBalancer.account,
+    ).then((builtCommand) => {
+      ManifestWizard.show({ title: 'Edit Manifest', application: this.app, command: builtCommand });
+    });
+  }
+
+  private extractLoadBalancer({ accountId, name, region }: ILoadBalancerFromStateParams): void {
+    const loadBalancer = this.app.getDataSource('loadBalancers').data.find((test: ILoadBalancer) => {
+      return test.name === name && test.account === accountId && test.region === region;
+    });
+
+    if (!loadBalancer) {
+      return this.autoClose();
+    }
+
+    ManifestReader.getManifest(accountId, region, name).then((manifest: IManifest) => {
+      this.manifest = manifest;
+      this.loadBalancer = loadBalancer;
+      this.state.loading = false;
+    });
+  }
+
+  private autoClose(): void {
+    if (this.$scope.$$destroyed) {
+      return;
+    } else {
+      this.$state.params.allowModalToStayOpen = true;
+      this.$state.go('^', null, { location: 'replace' });
+    }
+  }
+}
+
+export const KUBERNETES_LOAD_BALANCER_DETAILS_CTRL = 'spinnaker.kubernetes.loadBalancerDetails.controller';
+module(KUBERNETES_LOAD_BALANCER_DETAILS_CTRL, []).controller(
+  'kubernetesV2LoadBalancerDetailsCtrl',
+  KubernetesLoadBalancerDetailsController,
+);