@spinnaker/kubernetes 0.0.0-2025.1-0

package/src/serverGroupManager/details/ServerGroupManagerActions.tsx

@@ -0,0 +1,171 @@
+import { orderBy } from 'lodash';
+import React from 'react';
+import { Dropdown, MenuItem } from 'react-bootstrap';
+
+import type { Application, IManifest } from '@spinnaker/core';
+import {
+  AddEntityTagLinks,
+  ClusterTargetBuilder,
+  IfFeatureEnabled,
+  ModalInjector,
+  NameUtils,
+  robotToHuman,
+  SETTINGS,
+} from '@spinnaker/core';
+
+import type { IKubernetesServerGroupManager } from '../../interfaces';
+import { KubernetesManifestCommandBuilder } from '../../manifest';
+import { RollingRestart } from '../../manifest/rollout/RollingRestart';
+import { ManifestWizard } from '../../manifest/wizard/ManifestWizard';
+
+export interface IServerGroupManagerActionsProps {
+  application: Application;
+  serverGroupManager: IKubernetesServerGroupManager;
+  manifest: IManifest;
+}
+
+export function ServerGroupManagerActions({
+  application,
+  serverGroupManager,
+  manifest,
+}: IServerGroupManagerActionsProps) {
+  const isEnabled = SETTINGS.kubernetesAdHocInfraWritesEnabled;
+  const entityTagTargets = ClusterTargetBuilder.buildManagerClusterTargets(serverGroupManager);
+
+  const pauseRolloutServerGroupManager = (): void => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/rollout/pause.html'),
+      controller: 'kubernetesV2ManifestPauseRolloutCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroupManager.name,
+          namespace: serverGroupManager.namespace,
+          account: serverGroupManager.account,
+        },
+        application: application,
+      },
+    });
+  };
+
+  const resumeRolloutServerGroupManager = (): void => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/rollout/resume.html'),
+      controller: 'kubernetesV2ManifestResumeRolloutCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroupManager.name,
+          namespace: serverGroupManager.namespace,
+          account: serverGroupManager.account,
+        },
+        application: application,
+      },
+    });
+  };
+
+  const canUndoRolloutServerGroupManager = (): boolean => {
+    return serverGroupManager && serverGroupManager.serverGroups && serverGroupManager.serverGroups.length > 0;
+  };
+
+  const undoRolloutServerGroupManager = (): void => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/rollout/undo.html'),
+      controller: 'kubernetesV2ManifestUndoRolloutCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroupManager.name,
+          namespace: serverGroupManager.namespace,
+          account: serverGroupManager.account,
+        },
+        revisions: () => {
+          const [, ...rest] = orderBy(serverGroupManager.serverGroups, ['moniker.sequence'], ['desc']);
+          return rest.map((serverGroup, index) => ({
+            label: `${NameUtils.getSequence(serverGroup.moniker.sequence)}${index > 0 ? '' : ' - previous revision'}`,
+            revision: serverGroup.moniker.sequence,
+          }));
+        },
+        application: application,
+      },
+    });
+  };
+
+  const scaleServerGroupManager = () => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/scale/scale.html'),
+      controller: 'kubernetesV2ManifestScaleCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroupManager.name,
+          namespace: serverGroupManager.namespace,
+          account: serverGroupManager.account,
+        },
+        currentReplicas: manifest.manifest.spec.replicas,
+        application: application,
+      },
+    });
+  };
+
+  const editServerGroupManager = (): void => {
+    KubernetesManifestCommandBuilder.buildNewManifestCommand(
+      application,
+      manifest.manifest,
+      serverGroupManager.moniker,
+      serverGroupManager.account,
+    ).then((builtCommand) => {
+      ManifestWizard.show({ title: 'Edit Manifest', application: application, command: builtCommand });
+    });
+  };
+
+  const deleteServerGroupManager = (): void => {
+    ModalInjector.modalService.open({
+      templateUrl: require('../../manifest/delete/delete.html'),
+      controller: 'kubernetesV2ManifestDeleteCtrl as ctrl',
+      resolve: {
+        coordinates: {
+          name: serverGroupManager.name,
+          namespace: serverGroupManager.namespace,
+          account: serverGroupManager.account,
+        },
+        application: application,
+        manifestController: (): string => null,
+      },
+    });
+  };
+
+  return (
+    <Dropdown className="dropdown" id="server-group-manager-actions-dropdown">
+      {isEnabled && (
+        <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">
+          {robotToHuman(serverGroupManager.kind)} Actions
+        </Dropdown.Toggle>
+      )}
+      <Dropdown.Menu>
+        <MenuItem onClick={scaleServerGroupManager}>Scale</MenuItem>
+        {canUndoRolloutServerGroupManager() && (
+          <MenuItem onClick={undoRolloutServerGroupManager}>Undo Rollout</MenuItem>
+        )}
+        {manifest.status.paused.state && <MenuItem onClick={resumeRolloutServerGroupManager}>Resume Rollout</MenuItem>}
+        {!manifest.status.paused.state && !manifest.status.stable.state && (
+          <MenuItem onClick={pauseRolloutServerGroupManager}>Pause Rollout</MenuItem>
+        )}
+        {!manifest.status.paused.state && (
+          <RollingRestart application={application} serverGroupManager={serverGroupManager} />
+        )}
+        <MenuItem className="divider" />
+        <MenuItem onClick={editServerGroupManager}>Edit</MenuItem>
+        <MenuItem onClick={deleteServerGroupManager}>Delete</MenuItem>
+        <IfFeatureEnabled
+          feature="entityTags"
+          render={
+            <AddEntityTagLinks
+              component={serverGroupManager}
+              application={application}
+              entityType="serverGroupManager"
+              ownerOptions={entityTagTargets}
+              onUpdate={() => application.serverGroupManagers.refresh()}
+            />
+          }
+        />
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+}

package/src/serverGroupManager/details/ServerGroupManagerDetails.tsx

@@ -0,0 +1,72 @@
+import React from 'react';
+
+import type { Application, IServerGroupManagerDetailsProps, IServerGroupManagerStateParams } from '@spinnaker/core';
+import { CloudProviderLogo, Details, EntityNotifications, IfFeatureEnabled, ReactInjector } from '@spinnaker/core';
+
+import { ServerGroupManagerActions } from './ServerGroupManagerActions';
+import {
+  ServerGroupManagerAnnotationCustomSection,
+  ServerGroupManagerArtifactsSection,
+  ServerGroupManagerEventsSection,
+  ServerGroupManagerInformationSection,
+  ServerGroupManagerLabelsSection,
+  ServerGroupManagerManifestConditionSection,
+  ServerGroupManagerManifestStatusSection,
+} from './sections';
+import { useKubernetesServerGroupManagerDetails } from './useKubernetesServerGroupManagerDetails';
+
+export interface IKubernetesServerGroupManagerDetailsProps extends IServerGroupManagerDetailsProps {
+  app: Application;
+  serverGroupManager: IServerGroupManagerStateParams;
+}
+
+export function ServerGroupManagerDetails(props: IKubernetesServerGroupManagerDetailsProps) {
+  const autoClose = () => {
+    ReactInjector.$state.params.allowModalToStayOpen = true;
+    ReactInjector.$state.go('^', null, { location: 'replace' });
+  };
+  const [serverGroupManager, manifest, loading] = useKubernetesServerGroupManagerDetails(props, autoClose);
+
+  if (loading) return <Details loading={loading} />;
+
+  return (
+    <Details loading={loading}>
+      <Details.Header
+        icon={<CloudProviderLogo provider={props.serverGroupManager.provider} height="36px" width="36px" />}
+        name={serverGroupManager.displayName}
+        notifications={
+          <IfFeatureEnabled
+            feature="entityTags"
+            render={
+              <EntityNotifications
+                entity={serverGroupManager}
+                application={props.app}
+                placement="bottom"
+                hOffsetPercent="90%"
+                entityType="serverGroupManager"
+                pageLocation="details"
+                onUpdate={() => props.app.serverGroupManagers.refresh()}
+              />
+            }
+          />
+        }
+        actions={
+          <ServerGroupManagerActions
+            application={props.app}
+            serverGroupManager={serverGroupManager}
+            manifest={manifest}
+          />
+        }
+      />
+      <Details.Content loading={loading}>
+        <ServerGroupManagerManifestStatusSection serverGroupManager={serverGroupManager} manifest={manifest} />
+        <ServerGroupManagerInformationSection serverGroupManager={serverGroupManager} manifest={manifest} />
+        <ServerGroupManagerManifestConditionSection serverGroupManager={serverGroupManager} manifest={manifest} />
+        <ServerGroupManagerAnnotationCustomSection serverGroupManager={serverGroupManager} manifest={manifest} />
+        <ServerGroupManagerEventsSection serverGroupManager={serverGroupManager} manifest={manifest} />
+        <ServerGroupManagerLabelsSection serverGroupManager={serverGroupManager} manifest={manifest} />
+        <ServerGroupManagerArtifactsSection serverGroupManager={serverGroupManager} manifest={manifest} />
+      </Details.Content>
+    </Details>
+  );
+}

package/src/serverGroupManager/details/sections/IKubernetesServerGroupManagerDetailsSectionProps.ts

@@ -0,0 +1,7 @@
+import type { IManifest, IServerGroupManagerDetailsProps } from '@spinnaker/core';
+import type { IKubernetesServerGroupManager } from '../../../interfaces';
+
+export interface IKubernetesServerGroupManagerDetailsSectionProps extends IServerGroupManagerDetailsProps {
+  serverGroupManager: IKubernetesServerGroupManager;
+  manifest: IManifest;
+}

package/src/serverGroupManager/details/sections/ServerGroupManagerAnnotationCustomSection.tsx

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

package/src/serverGroupManager/details/sections/ServerGroupManagerArtifactsSection.tsx

@@ -0,0 +1,18 @@
+import React from 'react';
+
+import type { IArtifact } from '@spinnaker/core';
+import { CollapsibleSection } from '@spinnaker/core';
+import type { IKubernetesServerGroupManagerDetailsSectionProps } from './IKubernetesServerGroupManagerDetailsSectionProps';
+import { ManifestArtifact } from '../../../manifest';
+
+export function ServerGroupManagerArtifactsSection({ manifest }: IKubernetesServerGroupManagerDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Artifacts" defaultExpanded={true}>
+      {manifest.artifacts.map((artifact: IArtifact) => (
+        <ul key={artifact.reference}>
+          <ManifestArtifact artifact={artifact} />
+        </ul>
+      ))}
+    </CollapsibleSection>
+  );
+}

package/src/serverGroupManager/details/sections/ServerGroupManagerEventsSection.tsx

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

package/src/serverGroupManager/details/sections/ServerGroupManagerInformationSection.tsx

@@ -0,0 +1,51 @@
+import { UISref } from '@uirouter/react';
+import { orderBy } from 'lodash';
+import React from 'react';
+
+import type { IServerGroupSummary } from '@spinnaker/core';
+import { AccountTag, CollapsibleSection, robotToHuman, timestamp } from '@spinnaker/core';
+
+import type { IKubernetesServerGroupManagerDetailsSectionProps } from './IKubernetesServerGroupManagerDetailsSectionProps';
+
+export function ServerGroupManagerInformationSection({
+  serverGroupManager,
+}: IKubernetesServerGroupManagerDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Information" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>Created</dt>
+        <dd>{timestamp(serverGroupManager.createdTime)}</dd>
+        <dt>Account</dt>
+        <dd>
+          <AccountTag account={serverGroupManager.account} />
+        </dd>
+        <dt>Namespace</dt>
+        <dd>{serverGroupManager.namespace}</dd>
+        <dt>Kind</dt>
+        <dd>{serverGroupManager.kind}</dd>
+        {serverGroupManager.serverGroups.length > 0 && (
+          <>
+            <dt>Managing</dt>
+            <dd>
+              {orderBy(serverGroupManager.serverGroups, ['name'], ['asc']).map((serverGroup: IServerGroupSummary) => (
+                <ul key={serverGroup.name}>
+                  <UISref
+                    to="^.serverGroup"
+                    params={{
+                      region: serverGroup.region,
+                      accountId: serverGroup.account,
+                      serverGroup: serverGroup.name,
+                      provider: 'kubernetes',
+                    }}
+                  >
+                    <a>{robotToHuman(serverGroup.name)}</a>
+                  </UISref>
+                </ul>
+              ))}
+            </dd>
+          </>
+        )}
+      </dl>
+    </CollapsibleSection>
+  );
+}

package/src/serverGroupManager/details/sections/ServerGroupManagerLabelsSection.tsx

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

package/src/serverGroupManager/details/sections/ServerGroupManagerManifestConditionSection.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+
+import { CollapsibleSection } from '@spinnaker/core';
+
+import type { IKubernetesServerGroupManagerDetailsSectionProps } from './IKubernetesServerGroupManagerDetailsSectionProps';
+import type { IKubernetesManifestCondition } from '../../../manifest/status/ManifestCondition';
+import { ManifestCondition } from '../../../manifest/status/ManifestCondition';
+
+export function ServerGroupManagerManifestConditionSection({
+  manifest,
+}: IKubernetesServerGroupManagerDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Status" defaultExpanded={true}>
+      {manifest.manifest.status.conditions.map((condition: IKubernetesManifestCondition) => (
+        <ul key={condition.lastTransitionTime}>
+          <ManifestCondition condition={condition} />
+        </ul>
+      ))}
+    </CollapsibleSection>
+  );
+}

package/src/serverGroupManager/details/sections/ServerGroupManagerManifestStatusSection.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+
+import type { IKubernetesServerGroupManagerDetailsSectionProps } from './IKubernetesServerGroupManagerDetailsSectionProps';
+import { ManifestStatus } from '../../../manifest/status/ManifestStatus';
+
+export function ServerGroupManagerManifestStatusSection({
+  manifest,
+}: IKubernetesServerGroupManagerDetailsSectionProps) {
+  return <ManifestStatus status={manifest.status} />;
+}

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

@@ -0,0 +1,8 @@
+export * from './IKubernetesServerGroupManagerDetailsSectionProps';
+export * from './ServerGroupManagerAnnotationCustomSection';
+export * from './ServerGroupManagerArtifactsSection';
+export * from './ServerGroupManagerEventsSection';
+export * from './ServerGroupManagerInformationSection';
+export * from './ServerGroupManagerLabelsSection';
+export * from './ServerGroupManagerManifestConditionSection';
+export * from './ServerGroupManagerManifestStatusSection';

package/src/serverGroupManager/details/useKubernetesServerGroupManagerDetails.tsx

@@ -0,0 +1,53 @@
+import { useEffect, useState } from 'react';
+
+import type { IManifest, IServerGroupManager } from '@spinnaker/core';
+import { ManifestReader } from '@spinnaker/core';
+
+import type { IKubernetesServerGroupManagerDetailsProps } from './ServerGroupManagerDetails';
+import type { IKubernetesServerGroupManager } from '../../interfaces';
+
+export function useKubernetesServerGroupManagerDetails(
+  props: IKubernetesServerGroupManagerDetailsProps,
+  autoClose: () => void,
+): [IKubernetesServerGroupManager | undefined, IManifest | undefined, boolean] {
+  const [serverGroupManager, setServerGroupManager] = useState<IKubernetesServerGroupManager | undefined>();
+  const [manifest, setManifest] = useState<IManifest | undefined>();
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    if (serverGroupManager) {
+      return;
+    }
+
+    const { serverGroupManager: params, app } = props;
+    const { accountId, region, name } = params;
+
+    setLoading(true);
+
+    const serverGroupManagerDetails = app
+      .getDataSource('serverGroupManagers')
+      .data.find(
+        (manager: IServerGroupManager) =>
+          manager.name === name && manager.region === region && manager.account === accountId,
+      );
+
+    if (!serverGroupManagerDetails) {
+      autoClose();
+      return;
+    }
+
+    ManifestReader.getManifest(accountId, region, name)
+      .then((manifest: IManifest) => {
+        setManifest(manifest);
+        setServerGroupManager(serverGroupManagerDetails);
+      })
+      .catch((error) => {
+        console.error('Error fetching manifest:', error);
+      })
+      .finally(() => {
+        setLoading(false);
+      });
+  }, [autoClose, props, serverGroupManager]);
+
+  return [serverGroupManager, manifest, loading];
+}

package/src/serverGroupManager/index.ts

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

package/src/validation/applicationName.validator.spec.ts

@@ -0,0 +1,19 @@
+import { KubernetesApplicationNameValidator } from './applicationName.validator';
+
+describe('ApplicationNameValidator', () => {
+  const validator = new KubernetesApplicationNameValidator();
+  describe('validateSpecialCharacters', () => {
+    it('Returns no warnings or errors for names that contain only alphanumeric characters', () => {
+      expect(validator.validate('myapp123').errors.length).toEqual(0);
+      expect(validator.validate('myapp123').warnings.length).toEqual(0);
+    });
+    it('Returns no warnings or errors for names that contain only alphanumeric characters and dashes', () => {
+      expect(validator.validate('my-app-123').errors.length).toEqual(0);
+      expect(validator.validate('my-app-123').warnings.length).toEqual(0);
+    });
+    it('Returns an error for names that contain other non-alphanumeric characters', () => {
+      expect(validator.validate('my-app-123$').errors.length).toEqual(1);
+      expect(validator.validate('my-app-123$').warnings.length).toEqual(0);
+    });
+  });
+});

package/src/validation/applicationName.validator.ts

@@ -0,0 +1,44 @@
+import { ApplicationNameValidator } from '@spinnaker/core';
+
+export class KubernetesApplicationNameValidator {
+  // general k8s resource restriction: 253 characters - https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
+  // safe bet is 63 characters - (see also RFC 1035 or RFC 1123 - both setting DNS label maximum to 63 chars)
+  // for service names: - https://github.com/kubernetes/kubernetes/pull/29523 (until K8s 1.4.0 it was 24 characters https://github.com/kubernetes/kubernetes/issues/12463)
+  // or annotations:    - https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/#syntax-and-character-set
+  private static MAX_RESOURCE_NAME_LENGTH = 63;
+
+  private static validateSpecialCharacters(name: string, errors: string[]): void {
+    const alphanumWithDashPattern = /^([a-zA-Z][a-zA-Z0-9-]*)?$/;
+    if (!alphanumWithDashPattern.test(name)) {
+      errors.push(
+        'The application name must begin with a letter and must contain only letters, digits, or dashes. ' +
+          'No special characters are allowed.',
+      );
+    }
+  }
+
+  private static validateLength(name: string, errors: string[]): void {
+    if (name.length > KubernetesApplicationNameValidator.MAX_RESOURCE_NAME_LENGTH) {
+      errors.push(
+        `The maximum length for an application in Kubernetes is ${KubernetesApplicationNameValidator.MAX_RESOURCE_NAME_LENGTH} characters.`,
+      );
+    }
+  }
+
+  public validate(name = '') {
+    const warnings: string[] = [];
+    const errors: string[] = [];
+
+    if (name && name.length) {
+      KubernetesApplicationNameValidator.validateSpecialCharacters(name, errors);
+      KubernetesApplicationNameValidator.validateLength(name, errors);
+    }
+
+    return {
+      warnings,
+      errors,
+    };
+  }
+}
+
+ApplicationNameValidator.registerValidator('kubernetes', new KubernetesApplicationNameValidator());