@spinnaker/kubernetes 0.0.0-2025.1-0

package/src/serverGroup/details/KubernetesServerGroupActions.tsx

@@ -0,0 +1,138 @@
+import React from 'react';
+import { Dropdown, MenuItem } from 'react-bootstrap';
+
+import type { IOwnerOption, IServerGroupActionsProps } from '@spinnaker/core';
+import {
+  AddEntityTagLinks,
+  ClusterTargetBuilder,
+  ConfirmationModalService,
+  ModalInjector,
+  robotToHuman,
+  SETTINGS,
+} from '@spinnaker/core';
+
+import type { IKubernetesServerGroupView } from '../../interfaces';
+import { KubernetesManifestCommandBuilder } from '../../manifest';
+import { ManifestTrafficService } from '../../manifest/traffic/ManifestTrafficService';
+import { ManifestWizard } from '../../manifest/wizard/ManifestWizard';
+import { useManifest } from './useManifest';
+
+export interface IKubernetesServerGroupActionsProps extends IServerGroupActionsProps {
+  serverGroup: IKubernetesServerGroupView;
+}
+
+export function KubernetesServerGroupActions({ app, serverGroup }: IKubernetesServerGroupActionsProps) {
+  const showEntityTags = SETTINGS.feature && SETTINGS.feature.entityTags;
+  const entityTagTargets: IOwnerOption[] = ClusterTargetBuilder.buildClusterTargets(serverGroup);
+  const { manifest } = serverGroup;
+  const { manifestController } = useManifest({ manifest });
+
+  const canScaleServerGroup = (): boolean => {
+    return serverGroup.kind !== 'daemonSet' && manifestController === null;
+  };
+
+  const scaleServerGroup = () => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/scale/scale.html'),
+      controller: 'kubernetesV2ManifestScaleCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroup.name,
+          namespace: serverGroup.namespace,
+          account: serverGroup.account,
+        },
+        currentReplicas: manifest.manifest.spec.replicas,
+        application: app,
+      },
+    });
+  };
+
+  const canEditServerGroup = (): boolean => {
+    return manifestController === null;
+  };
+
+  const editServerGroup = (): void => {
+    KubernetesManifestCommandBuilder.buildNewManifestCommand(
+      app,
+      manifest.manifest,
+      serverGroup.moniker,
+      serverGroup.account,
+    ).then((builtCommand) => {
+      ManifestWizard.show({ title: 'Edit Manifest', application: app, command: builtCommand });
+    });
+  };
+
+  const deleteServerGroup = () => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/delete/delete.html'),
+      controller: 'kubernetesV2ManifestDeleteCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroup.name,
+          namespace: serverGroup.namespace,
+          account: serverGroup.account,
+        },
+        manifestController: () => manifestController,
+        application: app,
+      },
+    });
+  };
+
+  const canDisable = () => ManifestTrafficService.canDisableServerGroup(serverGroup);
+
+  const disableServerGroup = (): void => {
+    ConfirmationModalService.confirm({
+      header: `Really disable ${manifest.name}?`,
+      buttonText: 'Disable',
+      askForReason: true,
+      submitJustWithReason: true,
+      submitMethod: ({ reason }: { reason: string }) => ManifestTrafficService.disable(manifest, app, reason),
+      taskMonitorConfig: {
+        application: app,
+        title: `Disabling ${manifest.name}`,
+        onTaskComplete: () => app.getDataSource('serverGroups').refresh(),
+      },
+    });
+  };
+
+  const canEnable = () => ManifestTrafficService.canEnableServerGroup(serverGroup);
+
+  const enableServerGroup = (): void => {
+    ConfirmationModalService.confirm({
+      header: `Really enable ${manifest.name}?`,
+      buttonText: 'Enable',
+      askForReason: true,
+      submitJustWithReason: true,
+      submitMethod: ({ reason }: { reason: string }) => ManifestTrafficService.enable(manifest, app, reason),
+      taskMonitorConfig: {
+        application: app,
+        title: `Enabling ${manifest.name}`,
+        onTaskComplete: () => app.getDataSource('serverGroups').refresh(),
+      },
+    });
+  };
+
+  return (
+    <Dropdown className="dropdown" id="server-group-actions-dropdown">
+      <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">
+        {robotToHuman(serverGroup.kind)} Actions
+      </Dropdown.Toggle>
+      <Dropdown.Menu>
+        {canEditServerGroup() && <MenuItem onClick={editServerGroup}>Edit</MenuItem>}
+        {canScaleServerGroup() && <MenuItem onClick={scaleServerGroup}>Scale</MenuItem>}
+        {canEnable() && <MenuItem onClick={enableServerGroup}>Enable</MenuItem>}
+        {canDisable() && <MenuItem onClick={disableServerGroup}>Disable</MenuItem>}
+        <MenuItem onClick={deleteServerGroup}>Delete</MenuItem>
+        {showEntityTags && (
+          <AddEntityTagLinks
+            component={serverGroup}
+            application={app}
+            entityType="serverGroup"
+            ownerOptions={entityTagTargets}
+            onUpdate={() => app.serverGroups.refresh()}
+          />
+        )}
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+}

package/src/serverGroup/details/kubernetesServerGroupDetailsGetter.ts

@@ -0,0 +1,63 @@
+import { isEmpty } from 'lodash';
+import { Observable } from 'rxjs';
+
+import type { IManifest, IServerGroupDetailsProps } from '@spinnaker/core';
+import { ManifestReader, ServerGroupReader } from '@spinnaker/core';
+import type { IKubernetesLoadBalancer, IKubernetesServerGroup, IKubernetesServerGroupView } from '../../interfaces';
+
+function extractServerGroupSummary(props: IServerGroupDetailsProps): PromiseLike<IKubernetesServerGroup> {
+  const { app, serverGroup } = props;
+  return app.ready().then(() => {
+    let summary: IKubernetesServerGroup = app.serverGroups.data.find((toCheck: IKubernetesServerGroup) => {
+      return (
+        toCheck.name === serverGroup.name &&
+        toCheck.account === serverGroup.accountId &&
+        toCheck.region === serverGroup.region
+      );
+    });
+    if (!summary) {
+      app.loadBalancers.data.some((loadBalancer: IKubernetesLoadBalancer) => {
+        if (loadBalancer.account === serverGroup.accountId && loadBalancer.region === serverGroup.region) {
+          return loadBalancer.serverGroups.some((possibleServerGroup: IKubernetesServerGroup) => {
+            if (possibleServerGroup.name === serverGroup.name) {
+              summary = possibleServerGroup;
+              return true;
+            }
+            return false;
+          });
+        }
+        return false;
+      });
+    }
+    return summary;
+  });
+}
+
+export function kubernetesServerGroupDetailsGetter(
+  props: IServerGroupDetailsProps,
+  autoClose: () => void,
+): Observable<IKubernetesServerGroupView> {
+  const { app, serverGroup: serverGroupInfo } = props;
+  return new Observable<IKubernetesServerGroupView>((observer) => {
+    extractServerGroupSummary(props).then((summary) => {
+      Promise.all([
+        ServerGroupReader.getServerGroup(
+          app.name,
+          serverGroupInfo.accountId,
+          serverGroupInfo.region,
+          serverGroupInfo.name,
+        ),
+        ManifestReader.getManifest(serverGroupInfo.accountId, serverGroupInfo.region, serverGroupInfo.name),
+      ]).then(([serverGroup, manifest]: [IKubernetesServerGroupView, IManifest]) => {
+        // it's possible the summary was not found because the clusters are still loading
+        Object.assign(serverGroup, summary, { account: serverGroupInfo.accountId });
+        serverGroup.manifest = manifest;
+        if (!isEmpty(serverGroup)) {
+          observer.next(serverGroup);
+        } else {
+          autoClose();
+        }
+      }, autoClose);
+    }, autoClose);
+  });
+}

package/src/serverGroup/details/sections/IKubernetesServerGroupDetailsSectionProps.ts

@@ -0,0 +1,6 @@
+import type { IServerGroupDetailsSectionProps } from '@spinnaker/core';
+import type { IKubernetesServerGroupView } from '../../../interfaces';
+
+export interface IKubernetesServerGroupDetailsSectionProps extends IServerGroupDetailsSectionProps {
+  serverGroup: IKubernetesServerGroupView;
+}

package/src/serverGroup/details/sections/ServerGroupAnnotationCustomSection.tsx

@@ -0,0 +1,11 @@
+import React from 'react';
+
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+import { KubernetesReactInjector } from '../../../reactShims';
+
+export function ServerGroupAnnotationCustomSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  const { manifest } = serverGroup;
+  const { KubernetesAnnotationCustomSections } = KubernetesReactInjector;
+
+  return <KubernetesAnnotationCustomSections manifest={manifest.manifest} resource={serverGroup} />;
+}

package/src/serverGroup/details/sections/ServerGroupEventsSection.tsx

@@ -0,0 +1,14 @@
+import React from 'react';
+
+import { CollapsibleSection } from '@spinnaker/core';
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+import { ManifestEvents } from '../../../pipelines/stages/deployManifest/manifestStatus/ManifestEvents';
+
+export function ServerGroupEventsSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  const { manifest } = serverGroup;
+  return (
+    <CollapsibleSection heading="Events" defaultExpanded={true}>
+      <ManifestEvents manifest={manifest} />
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/details/sections/ServerGroupHealthSection.tsx

@@ -0,0 +1,19 @@
+import React from 'react';
+
+import { CollapsibleSection, HealthCounts } from '@spinnaker/core';
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+
+export function ServerGroupHealthSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Health" defaultExpanded={true}>
+      {serverGroup && (
+        <dl className="dl-horizontal dl-narrow">
+          <dt>Instances</dt>
+          <dd>
+            <HealthCounts container={serverGroup.instanceCounts} className="pull-left" />
+          </dd>
+        </dl>
+      )}
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/details/sections/ServerGroupImagesSection.tsx

@@ -0,0 +1,14 @@
+import React from 'react';
+
+import { CollapsibleSection } from '@spinnaker/core';
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+import { ManifestImageDetails } from '../../../manifest/ManifestImageDetails';
+
+export function ServerGroupImagesSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  const { manifest } = serverGroup;
+  return (
+    <CollapsibleSection heading="Images" defaultExpanded={true}>
+      <ManifestImageDetails manifest={manifest.manifest} />
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/details/sections/ServerGroupInformationSection.tsx

@@ -0,0 +1,46 @@
+import { UISref } from '@uirouter/react';
+
+import React from 'react';
+import { AccountTag, CollapsibleSection, robotToHuman, timestamp } from '@spinnaker/core';
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+import { useManifest } from '../useManifest';
+
+export function ServerGroupInformationSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  const { manifest } = serverGroup;
+  const { manifestController } = useManifest({ manifest });
+
+  return (
+    <CollapsibleSection heading="Information" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>Created</dt>
+        <dd>{timestamp(serverGroup.createdTime)}</dd>
+        <dt>Account</dt>
+        <dd>
+          <AccountTag account={serverGroup.account} />
+        </dd>
+        <dt>Namespace</dt>
+        <dd>{serverGroup.namespace}</dd>
+        <dt>Kind</dt>
+        <dd>{serverGroup.kind}</dd>
+        {manifestController && (
+          <>
+            <dt>Controller</dt>
+            <UISref
+              to="^.serverGroupManager"
+              params={{
+                accountId: serverGroup.account,
+                region: serverGroup.region,
+                serverGroupManager: manifestController,
+                provider: 'kubernetes',
+              }}
+            >
+              <a>
+                <dd>{robotToHuman(manifestController)}</dd>
+              </a>
+            </UISref>
+          </>
+        )}
+      </dl>
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/details/sections/ServerGroupLabelsSection.tsx

@@ -0,0 +1,14 @@
+import React from 'react';
+
+import { CollapsibleSection } from '@spinnaker/core';
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+import { ManifestLabels } from '../../../manifest/ManifestLabels';
+
+export function ServerGroupLabelsSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  const { manifest } = serverGroup;
+  return (
+    <CollapsibleSection heading="Labels" defaultExpanded={true}>
+      <ManifestLabels manifest={manifest.manifest} />
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/details/sections/ServerGroupManifestStatusSection.tsx

@@ -0,0 +1,9 @@
+import React from 'react';
+
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+import { ManifestStatus } from '../../../manifest/status/ManifestStatus';
+
+export function ServerGroupManifestStatusSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  const { manifest } = serverGroup;
+  return <ManifestStatus status={manifest.status} />;
+}

package/src/serverGroup/details/sections/ServerGroupSizeSection.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+
+import { CollapsibleSection } from '@spinnaker/core';
+import type { IKubernetesServerGroupDetailsSectionProps } from './IKubernetesServerGroupDetailsSectionProps';
+
+export function ServerGroupSizeSection({ serverGroup }: IKubernetesServerGroupDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Size" defaultExpanded={true}>
+      {serverGroup.capacity.min == null && (
+        <dl className="dl-horizontal dl-narrow">
+          <dt>Current</dt>
+          <dd>{serverGroup.instances.length}</dd>
+        </dl>
+      )}
+      {serverGroup.capacity.min != null && serverGroup.capacity.min === serverGroup.capacity.max && (
+        <dl className="dl-horizontal dl-narrow">
+          <dt>Min/Max</dt>
+          <dd>{serverGroup.capacity.min}</dd>
+          <dt>Current</dt>
+          <dd>{serverGroup.instances.length}</dd>
+        </dl>
+      )}
+      {serverGroup.capacity.min !== serverGroup.capacity.max && (
+        <dl className="dl-horizontal dl-narrow">
+          <dt>Min</dt>
+          <dd>{serverGroup.capacity.min}</dd>
+          <dt>Max</dt>
+          <dd>{serverGroup.capacity.max}</dd>
+          <dt>Current</dt>
+          <dd>{serverGroup.instances.length}</dd>
+        </dl>
+      )}
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/details/sections/index.ts

@@ -0,0 +1,9 @@
+export * from './IKubernetesServerGroupDetailsSectionProps';
+export * from './ServerGroupAnnotationCustomSection';
+export * from './ServerGroupEventsSection';
+export * from './ServerGroupHealthSection';
+export * from './ServerGroupImagesSection';
+export * from './ServerGroupInformationSection';
+export * from './ServerGroupLabelsSection';
+export * from './ServerGroupManifestStatusSection';
+export * from './ServerGroupSizeSection';

package/src/serverGroup/details/useManifest.ts

@@ -0,0 +1,42 @@
+import type { IManifest } from '@spinnaker/core';
+
+interface IUseManifestProps {
+  manifest: IManifest;
+}
+
+export function useManifest({ manifest }: IUseManifestProps) {
+  const ownerReferences = (): any[] => {
+    const manifestRaw = manifest.manifest;
+    if (
+      manifestRaw != null &&
+      manifestRaw.hasOwnProperty('metadata') &&
+      manifestRaw.metadata.hasOwnProperty('ownerReferences') &&
+      Array.isArray(manifestRaw.metadata.ownerReferences)
+    ) {
+      return manifestRaw.metadata.ownerReferences;
+    } else {
+      return [] as any[];
+    }
+  };
+
+  const ownerIsController = (ownerReference: any): boolean => {
+    return ownerReference.hasOwnProperty('controller') && ownerReference.controller === true;
+  };
+
+  const lowerCaseFirstLetter = (s: string): string => {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+  };
+
+  const manifestController = (): string | null => {
+    const controller = ownerReferences().find(ownerIsController);
+    if (typeof controller === 'undefined') {
+      return null;
+    } else {
+      return lowerCaseFirstLetter(controller.kind) + ' ' + controller.name;
+    }
+  };
+
+  return {
+    manifestController: manifestController(),
+  };
+}

package/src/serverGroup/index.ts

@@ -0,0 +1,3 @@
+export * from './details/sections';
+export * from './serverGroupCommandBuilder';
+export * from './serverGroupTransformer';

package/src/serverGroup/serverGroupCommandBuilder.ts

@@ -0,0 +1,9 @@
+import type { Application } from '@spinnaker/core';
+import type { IKubernetesManifestCommandData } from '../manifest/manifestCommandBuilder.service';
+import { KubernetesManifestCommandBuilder } from '../manifest/manifestCommandBuilder.service';
+
+export class KubernetesV2ServerGroupCommandBuilder {
+  public buildNewServerGroupCommand(app: Application): PromiseLike<IKubernetesManifestCommandData> {
+    return KubernetesManifestCommandBuilder.buildNewManifestCommand(app);
+  }
+}

package/src/serverGroup/serverGroupTransformer.spec.ts

@@ -0,0 +1,67 @@
+import { Application } from '@spinnaker/core';
+
+import type { IKubernetesServerGroup } from '../interfaces';
+import { KubernetesV2ServerGroupTransformer } from './serverGroupTransformer';
+
+describe('KubernetesV2ServerGroupTransformer', function () {
+  it('normalizes server group name', async () => {
+    const transformer = new KubernetesV2ServerGroupTransformer();
+    const ACCOUNT = 'myaccount';
+    const LOCATION = 'myns';
+    const SG_MANAGER = 'sgmanager';
+    const KIND = 'daemonSet';
+
+    const sgMgrRef = { account: ACCOUNT, location: LOCATION, name: SG_MANAGER };
+    const sgAccount = ({
+      account: ACCOUNT,
+      name: 'myservergroup',
+      region: LOCATION,
+      serverGroupManagers: [sgMgrRef],
+    } as unknown) as IKubernetesServerGroup;
+
+    const data = [{ name: `${KIND} ${SG_MANAGER}`, region: LOCATION, account: ACCOUNT, kind: KIND }];
+    const app = new Application('test', null, []);
+    app.getDataSource = () => {
+      return {
+        ready: () => Promise.resolve(data),
+        data,
+      } as any;
+    };
+
+    const sg = await transformer.normalizeServerGroup(sgAccount, app);
+    expect(sg).not.toBe(null);
+    expect(sg.serverGroupManagers.length).toBe(1);
+    expect(sgMgrRef.name).toBe('daemonSet sgmanager');
+  });
+
+  it('does not normalize server group if different account', async () => {
+    const transformer = new KubernetesV2ServerGroupTransformer();
+    const ACCOUNT = 'myaccount';
+    const ACCOUNT2 = 'account2';
+    const LOCATION = 'myns';
+    const SG_MANAGER = 'sgmanager';
+    const KIND = 'daemonSet';
+
+    const sgMgrRef = { account: ACCOUNT, location: LOCATION, name: SG_MANAGER };
+    const sgAccount: IKubernetesServerGroup = ({
+      account: ACCOUNT,
+      name: 'myservergroup',
+      region: LOCATION,
+      serverGroupManagers: [sgMgrRef],
+    } as unknown) as IKubernetesServerGroup;
+
+    const data = [{ name: `${KIND} ${SG_MANAGER}`, region: LOCATION, account: ACCOUNT2, kind: KIND }];
+    const app = new Application('test', null, []);
+    app.getDataSource = () => {
+      return {
+        ready: () => Promise.resolve(data),
+        data,
+      } as any;
+    };
+
+    const sg = await transformer.normalizeServerGroup(sgAccount, app);
+    expect(sg).not.toBe(null);
+    expect(sg.serverGroupManagers.length).toBe(1);
+    expect(sgMgrRef.name).toBe('sgmanager');
+  });
+});

package/src/serverGroup/serverGroupTransformer.ts

@@ -0,0 +1,27 @@
+import type { Application } from '@spinnaker/core';
+import type { IKubernetesServerGroup, IKubernetesServerGroupManager } from '../interfaces';
+
+export class KubernetesV2ServerGroupTransformer {
+  public normalizeServerGroup(
+    serverGroup: IKubernetesServerGroup,
+    application: Application,
+  ): PromiseLike<IKubernetesServerGroup> {
+    return application
+      .getDataSource('serverGroupManagers')
+      .ready()
+      .then((sgManagers: IKubernetesServerGroupManager[]) => {
+        (serverGroup.serverGroupManagers || []).forEach((managerRef) => {
+          const sgManager = sgManagers.find(
+            (manager: IKubernetesServerGroupManager) =>
+              managerRef.account == manager.account &&
+              managerRef.location == manager.region &&
+              `${manager.kind} ${managerRef.name}` == manager.name,
+          );
+          if (sgManager) {
+            managerRef.name = sgManager.name;
+          }
+        });
+        return serverGroup;
+      });
+  }
+}