@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/configure/wizard/GceServerGroupWizard.helpers.ts

@@ -0,0 +1,51 @@
+import type {
+  GceServerGroupLocationMode,
+  IGceServerGroupCommand,
+  IGceServerGroupCommandValidationErrors,
+  IPersistedReference,
+} from './GceServerGroupWizard.types';
+
+export function getGceServerGroupLocationMode(
+  command: Pick<IGceServerGroupCommand, 'regional'>,
+): GceServerGroupLocationMode {
+  return command.regional ? 'regional' : 'zonal';
+}
+
+export function preservePersistedReference<T>(
+  options: readonly T[],
+  persistedValue: string | null | undefined,
+  getValue: (option: T) => string,
+  createOption: (value: string) => T,
+): Array<IPersistedReference<T>> {
+  const references = options.map((value) => ({ value, unresolved: false }));
+  if (persistedValue && !options.some((option) => getValue(option) === persistedValue)) {
+    references.push({ value: createOption(persistedValue), unresolved: true });
+  }
+  return references;
+}
+
+export function validateGceServerGroupCommand(command: IGceServerGroupCommand): IGceServerGroupCommandValidationErrors {
+  const errors: IGceServerGroupCommandValidationErrors = {};
+  if (!command.application?.trim()) {
+    errors.application = 'Application required.';
+  }
+  if (!command.credentials?.trim()) {
+    errors.credentials = 'Account required.';
+  }
+  if (!command.region?.trim()) {
+    errors.region = 'Region required.';
+  }
+  if (!command.regional && !command.zone?.trim()) {
+    errors.zone = 'Zone required.';
+  }
+  if (command.regional && command.selectZones && !command.distributionPolicy?.zones?.length) {
+    errors.distributionPolicy = { zones: 'At least one zone required.' };
+  }
+  if (!command.viewState.disableImageSelection && !command.image?.trim()) {
+    errors.image = 'Image required.';
+  }
+  if (command.capacity?.desired === null || command.capacity?.desired === undefined) {
+    errors.capacity = { desired: 'Desired capacity required.' };
+  }
+  return errors;
+}

package/src/serverGroup/configure/wizard/GceServerGroupWizard.types.ts

@@ -0,0 +1,176 @@
+import type {
+  Application,
+  IPipeline,
+  IServerGroup,
+  IStage,
+  IWizardPageComponent,
+  IWizardPageInjectedProps,
+} from '@spinnaker/core';
+
+import type { IGceInstanceFlexibilityPolicy } from '../../../domain/serverGroup';
+
+export const GCE_SERVER_GROUP_OPERATION_MODES = ['create', 'clone', 'createPipeline', 'editPipeline'] as const;
+
+export type GceServerGroupOperationMode = typeof GCE_SERVER_GROUP_OPERATION_MODES[number];
+export type GceServerGroupLocationMode = 'zonal' | 'regional';
+
+export interface IGceServerGroupCommandUpdateResult {
+  dirty: Record<string, unknown>;
+}
+
+export interface IGceServerGroupCommand {
+  application?: string;
+  backingData?: any;
+  capacity?: {
+    desired?: number | null;
+    max?: number | null;
+    min?: number | null;
+  };
+  credentials?: string | null;
+  distributionPolicy?: {
+    targetShape?: string | null;
+    zones?: string[];
+  };
+  freeFormDetails?: string | null;
+  image?: string | null;
+  instanceFlexibilityPolicy?: IGceInstanceFlexibilityPolicy;
+  processCommandUpdateResult?: (result: IGceServerGroupCommandUpdateResult) => void;
+  region?: string | null;
+  regional: boolean;
+  selectZones?: boolean;
+  stack?: string | null;
+  viewState: {
+    dirty?: Record<string, unknown>;
+    disableImageSelection?: boolean;
+    mode: GceServerGroupOperationMode;
+    [key: string]: any;
+  };
+  zone?: string | null;
+  [key: string]: any;
+}
+
+export interface IGceServerGroupCommandDefaults {
+  account?: string;
+  mode?: GceServerGroupOperationMode;
+  region?: string;
+  zone?: string;
+}
+
+export interface IGceServerGroupCommandBuilderAdapter {
+  buildNewServerGroupCommand(
+    application: Application,
+    defaults?: IGceServerGroupCommandDefaults,
+  ): Promise<IGceServerGroupCommand>;
+  buildNewServerGroupCommandForPipeline(currentStage: IStage, pipeline: IPipeline): Promise<IGceServerGroupCommand>;
+  buildServerGroupCommandFromExisting(
+    application: Application,
+    serverGroup: IServerGroup,
+    mode?: GceServerGroupOperationMode,
+  ): Promise<IGceServerGroupCommand>;
+  buildServerGroupCommandFromPipeline(
+    application: Application,
+    originalCluster: Partial<IGceServerGroupCommand>,
+    currentStage: IStage,
+    pipeline: IPipeline,
+  ): Promise<IGceServerGroupCommand>;
+}
+
+export type GceConfigurationUpdateMethod =
+  | 'configureImages'
+  | 'configureInstanceTypes'
+  | 'configureLoadBalancerOptions'
+  | 'configureSubnets'
+  | 'configureZones';
+
+export type GceConfigurationRefreshMethod =
+  | 'refreshHealthChecks'
+  | 'refreshInstanceTypes'
+  | 'refreshLoadBalancers'
+  | 'refreshSecurityGroups';
+
+export type GceCommandHandlerName =
+  | 'credentialsChanged'
+  | 'customInstanceChanged'
+  | 'networkChanged'
+  | 'regionChanged'
+  | 'regionalChanged'
+  | 'selectZonesChanged'
+  | 'zoneChanged';
+
+export interface IGceServerGroupConfigurationAdapter {
+  configureCommand(application: Application, command: IGceServerGroupCommand): Promise<void>;
+  configureImages(command: IGceServerGroupCommand): IGceServerGroupCommandUpdateResult;
+  configureInstanceTypes(command: IGceServerGroupCommand): IGceServerGroupCommandUpdateResult;
+  configureLoadBalancerOptions(command: IGceServerGroupCommand): IGceServerGroupCommandUpdateResult;
+  configureSubnets(command: IGceServerGroupCommand): IGceServerGroupCommandUpdateResult;
+  configureZones(command: IGceServerGroupCommand): IGceServerGroupCommandUpdateResult;
+  refreshHealthChecks(command: IGceServerGroupCommand, skipCommandReconfiguration?: boolean): Promise<void>;
+  refreshInstanceTypes(command: IGceServerGroupCommand): Promise<void>;
+  refreshLoadBalancers(command: IGceServerGroupCommand, skipCommandReconfiguration?: boolean): Promise<void>;
+  refreshSecurityGroups(command: IGceServerGroupCommand, skipCommandReconfiguration?: boolean): Promise<void>;
+}
+
+export interface IGceServerGroupCommandUpdate {
+  command: IGceServerGroupCommand;
+  result: IGceServerGroupCommandUpdateResult;
+}
+
+export interface IGceServerGroupWizardAdapter {
+  buildNewServerGroupCommand(
+    application: Application,
+    defaults?: IGceServerGroupCommandDefaults,
+  ): Promise<IGceServerGroupCommand>;
+  configureCommand(application: Application, command: IGceServerGroupCommand): Promise<IGceServerGroupCommand>;
+  applyCommandHandler(
+    command: IGceServerGroupCommand,
+    handler: GceCommandHandlerName,
+  ): Promise<IGceServerGroupCommandUpdate>;
+  applyConfigurationUpdate(
+    command: IGceServerGroupCommand,
+    method: GceConfigurationUpdateMethod,
+  ): Promise<IGceServerGroupCommandUpdate>;
+  applyConfigurationRefresh(
+    command: IGceServerGroupCommand,
+    method: GceConfigurationRefreshMethod,
+    skipCommandReconfiguration?: boolean,
+  ): Promise<IGceServerGroupCommandUpdate>;
+}
+
+export interface IGceServerGroupWizardCommandState {
+  command: IGceServerGroupCommand;
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>;
+  formikValues: IGceServerGroupCommand;
+  requestGeneration: number;
+}
+
+export interface IGceServerGroupWizardFieldOrigin {
+  generation: number;
+  source: 'result' | 'user';
+}
+
+export interface IGceServerGroupWizardPageProps {
+  app: Application;
+  commandState?: IGceServerGroupWizardCommandState;
+  formik: IWizardPageInjectedProps<IGceServerGroupCommand>['formik'];
+  onLoadingChanged?: (isLoading: boolean) => void;
+  adapter?: IGceServerGroupWizardAdapter;
+}
+
+export type GceServerGroupWizardPageContract = IWizardPageComponent<IGceServerGroupCommand>;
+
+export interface IPersistedReference<T> {
+  unresolved: boolean;
+  value: T;
+}
+
+export interface IGceServerGroupCommandValidationErrors {
+  application?: string;
+  capacity?: { desired?: string };
+  credentials?: string;
+  distributionPolicy?: { zones?: string };
+  freeFormDetails?: string;
+  image?: string;
+  region?: string;
+  stack?: string;
+  zone?: string;
+}

package/src/serverGroup/configure/wizard/GceServerGroupWizardAdapter.ts

@@ -0,0 +1,115 @@
+import { cloneDeep } from 'lodash';
+
+import type { Application, IPipeline, IServerGroup, IStage } from '@spinnaker/core';
+import type {
+  GceCommandHandlerName,
+  GceConfigurationRefreshMethod,
+  GceConfigurationUpdateMethod,
+  GceServerGroupOperationMode,
+  IGceServerGroupCommand,
+  IGceServerGroupCommandBuilderAdapter,
+  IGceServerGroupCommandDefaults,
+  IGceServerGroupCommandUpdate,
+  IGceServerGroupCommandUpdateResult,
+  IGceServerGroupConfigurationAdapter,
+  IGceServerGroupWizardAdapter,
+} from './GceServerGroupWizard.types';
+
+const EMPTY_UPDATE_RESULT: IGceServerGroupCommandUpdateResult = { dirty: {} };
+
+export class GceServerGroupWizardAdapter implements IGceServerGroupWizardAdapter {
+  public constructor(
+    private commandBuilder: IGceServerGroupCommandBuilderAdapter,
+    private configurationService: IGceServerGroupConfigurationAdapter,
+  ) {}
+
+  public buildNewServerGroupCommand(
+    application: Application,
+    defaults?: IGceServerGroupCommandDefaults,
+  ): Promise<IGceServerGroupCommand> {
+    return this.commandBuilder.buildNewServerGroupCommand(application, defaults);
+  }
+
+  public buildNewServerGroupCommandForPipeline(
+    currentStage: IStage,
+    pipeline: IPipeline,
+  ): Promise<IGceServerGroupCommand> {
+    return this.commandBuilder.buildNewServerGroupCommandForPipeline(currentStage, pipeline);
+  }
+
+  public buildServerGroupCommandFromExisting(
+    application: Application,
+    serverGroup: IServerGroup,
+    mode?: GceServerGroupOperationMode,
+  ): Promise<IGceServerGroupCommand> {
+    return this.commandBuilder.buildServerGroupCommandFromExisting(application, serverGroup, mode);
+  }
+
+  public buildServerGroupCommandFromPipeline(
+    application: Application,
+    originalCluster: Partial<IGceServerGroupCommand>,
+    currentStage: IStage,
+    pipeline: IPipeline,
+  ): Promise<IGceServerGroupCommand> {
+    return this.commandBuilder.buildServerGroupCommandFromPipeline(
+      application,
+      originalCluster,
+      currentStage,
+      pipeline,
+    );
+  }
+
+  public async configureCommand(
+    application: Application,
+    command: IGceServerGroupCommand,
+  ): Promise<IGceServerGroupCommand> {
+    const nextCommand = cloneDeep(command);
+    await this.configurationService.configureCommand(application, nextCommand);
+    return nextCommand;
+  }
+
+  public applyCommandHandler(
+    command: IGceServerGroupCommand,
+    handler: GceCommandHandlerName,
+  ): Promise<IGceServerGroupCommandUpdate> {
+    return this.applyUpdate(command, (nextCommand) => nextCommand[handler]?.(nextCommand));
+  }
+
+  public applyConfigurationUpdate(
+    command: IGceServerGroupCommand,
+    method: GceConfigurationUpdateMethod,
+  ): Promise<IGceServerGroupCommandUpdate> {
+    return this.applyUpdate(command, (nextCommand) => this.configurationService[method](nextCommand));
+  }
+
+  public applyConfigurationRefresh(
+    command: IGceServerGroupCommand,
+    method: GceConfigurationRefreshMethod,
+    skipCommandReconfiguration?: boolean,
+  ): Promise<IGceServerGroupCommandUpdate> {
+    return this.applyUpdate(command, async (nextCommand) => {
+      if (method === 'refreshInstanceTypes') {
+        await this.configurationService.refreshInstanceTypes(nextCommand);
+      } else {
+        await this.configurationService[method](nextCommand, skipCommandReconfiguration);
+      }
+      return EMPTY_UPDATE_RESULT;
+    });
+  }
+
+  private async applyUpdate(
+    command: IGceServerGroupCommand,
+    update: (
+      nextCommand: IGceServerGroupCommand,
+    ) => IGceServerGroupCommandUpdateResult | void | Promise<IGceServerGroupCommandUpdateResult | void>,
+  ): Promise<IGceServerGroupCommandUpdate> {
+    const nextCommand = cloneDeep(command);
+    const result = (await update(nextCommand)) || EMPTY_UPDATE_RESULT;
+    nextCommand.viewState = {
+      ...nextCommand.viewState,
+      dirty: { ...nextCommand.viewState.dirty, ...result.dirty },
+    };
+    nextCommand.processCommandUpdateResult?.(result);
+    return { command: nextCommand, result };
+  }
+}