@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/configure/wizard/GceServerGroupWizardPage.tsx

@@ -0,0 +1,285 @@
+import { isEqual, isPlainObject } from 'lodash';
+import React from 'react';
+
+import type { IWizardPageComponent } from '@spinnaker/core';
+
+import type {
+  GceCommandHandlerName,
+  GceConfigurationRefreshMethod,
+  GceConfigurationUpdateMethod,
+  IGceServerGroupCommand,
+  IGceServerGroupWizardCommandState,
+  IGceServerGroupWizardFieldOrigin,
+  IGceServerGroupWizardPageProps,
+} from './GceServerGroupWizard.types';
+
+export function createGceServerGroupWizardCommandState(
+  command: IGceServerGroupCommand,
+): IGceServerGroupWizardCommandState {
+  return { command, fieldOrigins: {}, formikValues: command, requestGeneration: 0 };
+}
+
+export abstract class GceServerGroupWizardPage<
+    P extends IGceServerGroupWizardPageProps = IGceServerGroupWizardPageProps
+  >
+  extends React.Component<P>
+  implements IWizardPageComponent<IGceServerGroupCommand> {
+  private readonly commandState =
+    this.props.commandState || createGceServerGroupWizardCommandState(this.props.formik.values);
+
+  private requestGeneration = 0;
+  private isUnmounted = false;
+
+  protected get adapter() {
+    if (!this.props.adapter) {
+      throw new Error('GCE server group wizard pages require an adapter owned by the wizard modal');
+    }
+    return this.props.adapter;
+  }
+
+  public validate(_values: IGceServerGroupCommand): { [key: string]: any } {
+    return {};
+  }
+
+  public componentWillUnmount(): void {
+    this.isUnmounted = true;
+    this.requestGeneration++;
+  }
+
+  protected configureCommand(): Promise<IGceServerGroupCommand | undefined> {
+    return this.runLatestCommandRequest(this.props.formik.values, (command) =>
+      this.adapter.configureCommand(this.props.app, command),
+    );
+  }
+
+  protected applyCommandHandler(handler: GceCommandHandlerName): Promise<IGceServerGroupCommand | undefined> {
+    return this.runLatestCommandRequest(this.props.formik.values, async (command) => {
+      const update = await this.adapter.applyCommandHandler(command, handler);
+      return update.command;
+    });
+  }
+
+  protected applyConfigurationUpdate(
+    method: GceConfigurationUpdateMethod,
+  ): Promise<IGceServerGroupCommand | undefined> {
+    return this.runLatestCommandRequest(this.props.formik.values, async (command) => {
+      const update = await this.adapter.applyConfigurationUpdate(command, method);
+      return update.command;
+    });
+  }
+
+  protected applyConfigurationRefresh(
+    method: GceConfigurationRefreshMethod,
+    skipCommandReconfiguration?: boolean,
+  ): Promise<IGceServerGroupCommand | undefined> {
+    return this.runLatestCommandRequest(this.props.formik.values, async (command) => {
+      const update = await this.adapter.applyConfigurationRefresh(command, method, skipCommandReconfiguration);
+      return update.command;
+    });
+  }
+
+  protected async runLatestCommandRequest(
+    requestedCommand: IGceServerGroupCommand,
+    request: (command: IGceServerGroupCommand) => Promise<IGceServerGroupCommand>,
+  ): Promise<IGceServerGroupCommand | undefined> {
+    const pageGeneration = ++this.requestGeneration;
+    this.syncFormikValues();
+    const commandGeneration = ++this.commandState.requestGeneration;
+    const requestCommand = mergeCommandChanges(
+      this.props.formik.values,
+      requestedCommand,
+      this.commandState.command,
+      this.commandState.fieldOrigins,
+      { generation: commandGeneration, source: 'user' },
+      true,
+    );
+    this.commandState.command = requestCommand;
+    this.props.onLoadingChanged?.(true);
+    try {
+      const command = await request(requestCommand);
+      if (this.isUnmounted) {
+        return undefined;
+      }
+      this.syncFormikValues();
+      const currentCommand = this.commandState.command;
+      const mergedCommand = mergeCommandChanges(
+        requestCommand,
+        command,
+        currentCommand,
+        this.commandState.fieldOrigins,
+        { generation: commandGeneration, source: 'result' },
+      );
+      if (!isEqual(mergedCommand, currentCommand) || commandGeneration === this.commandState.requestGeneration) {
+        this.commandState.command = mergedCommand;
+        this.props.formik.setValues(mergedCommand);
+      }
+      return mergedCommand;
+    } finally {
+      if (!this.isUnmounted && pageGeneration === this.requestGeneration) {
+        this.props.onLoadingChanged?.(false);
+      }
+    }
+  }
+
+  private syncFormikValues(): void {
+    const { formikValues } = this.commandState;
+    if (formikValues === this.props.formik.values) {
+      return;
+    }
+    this.commandState.command = mergeCommandChanges(
+      formikValues,
+      this.props.formik.values,
+      this.commandState.command,
+      this.commandState.fieldOrigins,
+      { generation: this.commandState.requestGeneration, source: 'user' },
+    );
+    this.commandState.formikValues = this.props.formik.values;
+  }
+}
+
+function mergeCommandChanges(
+  base: IGceServerGroupCommand,
+  changed: IGceServerGroupCommand,
+  current: IGceServerGroupCommand,
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>,
+  incomingOrigin: IGceServerGroupWizardFieldOrigin,
+  markMatchingChanges = false,
+): IGceServerGroupCommand {
+  return mergeValueChanges(
+    base,
+    changed,
+    current,
+    fieldOrigins,
+    incomingOrigin,
+    [],
+    markMatchingChanges,
+  ) as IGceServerGroupCommand;
+}
+
+function mergeValueChanges(
+  base: any,
+  changed: any,
+  current: any,
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>,
+  incomingOrigin: IGceServerGroupWizardFieldOrigin,
+  path: string[],
+  markMatchingChanges: boolean,
+): any {
+  if (isEqual(changed, base)) {
+    return current;
+  }
+  if (isEqual(changed, current)) {
+    if (markMatchingChanges) {
+      recordChangedOrigins(base, changed, fieldOrigins, incomingOrigin, path);
+    }
+    return current;
+  }
+
+  if (
+    isPlainObject(changed) &&
+    (isPlainObject(base) || base === undefined) &&
+    (isPlainObject(current) || current === undefined)
+  ) {
+    const baseObject = base || {};
+    const currentObject = current || {};
+    const result = { ...currentObject };
+    new Set([...Object.keys(baseObject), ...Object.keys(changed)]).forEach((key) => {
+      const childPath = [...path, key];
+      if (!Object.prototype.hasOwnProperty.call(changed, key)) {
+        if (
+          isEqual(currentObject[key], baseObject[key]) ||
+          incomingWinsConflict(fieldOrigins, incomingOrigin, childPath)
+        ) {
+          delete result[key];
+          recordFieldOrigin(fieldOrigins, incomingOrigin, childPath);
+        }
+        return;
+      }
+      result[key] = mergeValueChanges(
+        baseObject[key],
+        changed[key],
+        currentObject[key],
+        fieldOrigins,
+        incomingOrigin,
+        childPath,
+        markMatchingChanges,
+      );
+    });
+    return result;
+  }
+
+  if (isEqual(current, base) || incomingWinsConflict(fieldOrigins, incomingOrigin, path)) {
+    recordFieldOrigin(fieldOrigins, incomingOrigin, path);
+    return changed;
+  }
+  return current;
+}
+
+function incomingWinsConflict(
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>,
+  incomingOrigin: IGceServerGroupWizardFieldOrigin,
+  path: string[],
+): boolean {
+  if (incomingOrigin.source === 'user') {
+    return true;
+  }
+  const currentOrigin = findFieldOrigin(fieldOrigins, path);
+  return currentOrigin?.source === 'result' && incomingOrigin.generation > currentOrigin.generation;
+}
+
+function findFieldOrigin(
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>,
+  path: string[],
+): IGceServerGroupWizardFieldOrigin | undefined {
+  for (let length = path.length; length >= 0; length--) {
+    const origin = fieldOrigins[fieldOriginKey(path.slice(0, length))];
+    if (origin) {
+      return origin;
+    }
+  }
+  return undefined;
+}
+
+function recordChangedOrigins(
+  base: any,
+  changed: any,
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>,
+  incomingOrigin: IGceServerGroupWizardFieldOrigin,
+  path: string[],
+): void {
+  if (isEqual(base, changed)) {
+    return;
+  }
+  if (isPlainObject(changed) && (isPlainObject(base) || base === undefined)) {
+    const baseObject = base || {};
+    new Set([...Object.keys(baseObject), ...Object.keys(changed)]).forEach((key) => {
+      const childPath = [...path, key];
+      if (!Object.prototype.hasOwnProperty.call(changed, key)) {
+        recordFieldOrigin(fieldOrigins, incomingOrigin, childPath);
+        return;
+      }
+      recordChangedOrigins(baseObject[key], changed[key], fieldOrigins, incomingOrigin, childPath);
+    });
+    return;
+  }
+  recordFieldOrigin(fieldOrigins, incomingOrigin, path);
+}
+
+function recordFieldOrigin(
+  fieldOrigins: Record<string, IGceServerGroupWizardFieldOrigin>,
+  incomingOrigin: IGceServerGroupWizardFieldOrigin,
+  path: string[],
+): void {
+  const key = fieldOriginKey(path);
+  const descendantPrefix = `${key}\u0000`;
+  Object.keys(fieldOrigins).forEach((originKey) => {
+    if (originKey.startsWith(descendantPrefix)) {
+      delete fieldOrigins[originKey];
+    }
+  });
+  fieldOrigins[key] = incomingOrigin;
+}
+
+function fieldOriginKey(path: string[]): string {
+  return path.join('\u0000');
+}

package/src/serverGroup/configure/wizard/customInstance/GceCustomInstanceBuilder.spec.tsx

@@ -0,0 +1,125 @@
+import { mount as enzymeMount } from 'enzyme';
+import React from 'react';
+
+import { DeckRuntimeContext } from '@spinnaker/core';
+import { CustomInstanceConfigurer } from './CustomInstanceConfigurer';
+import { GceCustomInstanceBuilder } from './GceCustomInstanceBuilder';
+
+describe('GceCustomInstanceBuilder', () => {
+  let runtimeServices: any;
+  const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) => (
+    <DeckRuntimeContext.Provider value={{ services: runtimeServices } as any}>{children}</DeckRuntimeContext.Provider>
+  );
+  const mount = (component: React.ReactElement) => enzymeMount(component, { wrappingComponent: RuntimeWrapper });
+
+  beforeEach(() => {
+    runtimeServices = {};
+  });
+
+  it('parses the current instance type and provides valid custom instance choices', () => {
+    runtimeServices.instanceTypeService = instanceTypeService();
+    const command = commandWithCustomInstance('n2-custom-4-16384-ext');
+
+    const component = mount(<GceCustomInstanceBuilder command={command as any} onTypeChanged={jasmine.createSpy()} />);
+    const configurer = component.find(CustomInstanceConfigurer);
+
+    expect(configurer.prop('selectedInstanceFamily')).toBe('N2');
+    expect(configurer.prop('selectedVCpuCount')).toBe(4);
+    expect(configurer.prop('selectedMemory')).toBe(16);
+    expect(configurer.prop('selectedExtendedMemory')).toBe(true);
+    expect(configurer.prop('instanceFamilyList')).toContain('N2D');
+    expect(configurer.prop('vCpuList')).toContain(4);
+    expect(configurer.prop('memoryList')).toContain(16);
+  });
+
+  it('updates command.instanceType, notifies, and loads details when custom choices change', async () => {
+    const instanceTypeDetails = { name: 'n2-custom-8-32768' };
+    runtimeServices.instanceTypeService = instanceTypeService(instanceTypeDetails);
+    const onTypeChanged = jasmine.createSpy('onTypeChanged');
+    const command = commandWithCustomInstance('n2-custom-4-16384');
+
+    const component = mount(<GceCustomInstanceBuilder command={command as any} onTypeChanged={onTypeChanged} />);
+    component.find(CustomInstanceConfigurer).prop('onChange')({
+      instanceFamily: 'N2',
+      vCpuCount: 8,
+      memory: 32,
+      extendedMemory: false,
+    });
+    await settle(component);
+
+    expect(command.instanceType).toBe('n2-custom-8-32768');
+    expect(command.customInstanceChanged).toHaveBeenCalledWith(command);
+    expect(onTypeChanged).toHaveBeenCalledWith('n2-custom-8-32768');
+    expect(command.viewState.instanceTypeDetails).toBe(instanceTypeDetails as any);
+  });
+
+  it('initializes missing custom values from valid lists', () => {
+    runtimeServices.instanceTypeService = instanceTypeService();
+    const command = commandWithCustomInstance(null);
+
+    const component = mount(<GceCustomInstanceBuilder command={command as any} onTypeChanged={jasmine.createSpy()} />);
+    const configurer = component.find(CustomInstanceConfigurer);
+
+    expect(configurer.prop('selectedInstanceFamily')).toBe('N1');
+    expect(configurer.prop('selectedVCpuCount')).toBe(1);
+    expect(configurer.prop('selectedMemory')).toBe(1);
+    expect(command.viewState.customInstance).toEqual({
+      extendedMemory: false,
+      instanceFamily: 'N1',
+      memory: 1,
+      vCpuCount: 1,
+    });
+  });
+
+  it('keeps valid defaults when memory changes before cores', async () => {
+    runtimeServices.instanceTypeService = instanceTypeService();
+    const onTypeChanged = jasmine.createSpy('onTypeChanged');
+    const command = commandWithCustomInstance(null);
+
+    const component = mount(<GceCustomInstanceBuilder command={command as any} onTypeChanged={onTypeChanged} />);
+    component.find(CustomInstanceConfigurer).prop('onChange')({
+      instanceFamily: 'N1',
+      vCpuCount: null,
+      memory: 4,
+      extendedMemory: false,
+    } as any);
+    await settle(component);
+
+    expect(command.instanceType).toBe('custom-1-4096');
+    expect(onTypeChanged).toHaveBeenCalledWith('custom-1-4096');
+  });
+});
+
+function commandWithCustomInstance(instanceType: string | null) {
+  return {
+    selectedProvider: 'gce',
+    instanceType,
+    region: 'us-central1',
+    regional: true,
+    viewState: {},
+    backingData: {
+      customInstanceTypes: {},
+      credentialsKeyedByAccount: {
+        test: {
+          locationToInstanceTypesMap: {
+            'us-central1': { vCpuMax: 16 },
+          },
+        },
+      },
+    },
+    credentials: 'test',
+    customInstanceChanged: jasmine.createSpy('customInstanceChanged'),
+  };
+}
+
+function instanceTypeService(details = { name: 'n2-custom-8-32768' }) {
+  return {
+    getInstanceTypeDetails: jasmine.createSpy('getInstanceTypeDetails').and.returnValue(Promise.resolve(details)),
+  };
+}
+
+async function settle(component: any) {
+  await Promise.resolve();
+  await Promise.resolve();
+  component.update();
+}

package/src/serverGroup/configure/wizard/customInstance/GceCustomInstanceBuilder.tsx

@@ -0,0 +1,127 @@
+import React from 'react';
+
+import type { ICustomInstanceBuilderProps } from '@spinnaker/core';
+import { useDeckRuntimeServices } from '@spinnaker/core';
+
+import type { ICustomInstanceConfig } from './CustomInstanceConfigurer';
+import { CustomInstanceConfigurer } from './CustomInstanceConfigurer';
+import { GceCustomInstanceBuilderService } from '../../../../instance/custom/customInstanceBuilder.gce.service';
+
+const customInstanceBuilderService = new GceCustomInstanceBuilderService();
+
+export function GceCustomInstanceBuilder({ command, onTypeChanged }: ICustomInstanceBuilderProps) {
+  const { instanceTypeService } = useDeckRuntimeServices();
+  const gceCommand = command as any;
+  const [config, setConfig] = React.useState<ICustomInstanceConfig>(() => getInitialConfig(gceCommand));
+  const choices = getChoices(gceCommand, config);
+  const effectiveConfig = withValidDefaults(config, choices);
+
+  const handleChange = (nextConfig: ICustomInstanceConfig) => {
+    const nextChoices = getChoices(gceCommand, nextConfig);
+    const completeConfig = withValidDefaults(nextConfig, nextChoices);
+    const nextInstanceType = customInstanceBuilderService.generateInstanceTypeString(
+      completeConfig.instanceFamily,
+      completeConfig.vCpuCount,
+      completeConfig.memory,
+      completeConfig.extendedMemory,
+    );
+    gceCommand.viewState.customInstance = completeConfig;
+    gceCommand.instanceType = nextInstanceType;
+    gceCommand.customInstanceChanged && gceCommand.customInstanceChanged(gceCommand);
+    setConfig(completeConfig);
+    instanceTypeService
+      .getInstanceTypeDetails(gceCommand.selectedProvider, nextInstanceType)
+      .then((instanceTypeDetails) => {
+        gceCommand.viewState.instanceTypeDetails = instanceTypeDetails;
+      });
+    onTypeChanged && onTypeChanged(nextInstanceType);
+  };
+
+  return (
+    <CustomInstanceConfigurer
+      instanceFamilyList={choices.instanceFamilyList}
+      memoryList={choices.memoryList}
+      onChange={handleChange}
+      selectedExtendedMemory={effectiveConfig.extendedMemory}
+      selectedInstanceFamily={effectiveConfig.instanceFamily}
+      selectedMemory={effectiveConfig.memory}
+      selectedVCpuCount={effectiveConfig.vCpuCount}
+      vCpuList={choices.vCpuList}
+    />
+  );
+}
+
+function getInitialConfig(command: any): ICustomInstanceConfig {
+  if (command.viewState.customInstance) {
+    return {
+      extendedMemory: isExtendedMemory(command.instanceType),
+      ...command.viewState.customInstance,
+    };
+  }
+
+  const parsed = command.instanceType
+    ? customInstanceBuilderService.parseInstanceTypeString(stripExtendedMemorySuffix(command.instanceType))
+    : { instanceFamily: 'N1', vCpuCount: null, memory: null };
+
+  const config = withValidDefaults(
+    {
+      ...parsed,
+      extendedMemory: isExtendedMemory(command.instanceType),
+    },
+    getChoices(command, parsed as Partial<ICustomInstanceConfig>),
+  );
+  command.viewState.customInstance = config;
+  return config;
+}
+
+function withValidDefaults(
+  config: Partial<ICustomInstanceConfig>,
+  choices: ReturnType<typeof getChoices>,
+): ICustomInstanceConfig {
+  const instanceFamily = config.instanceFamily || choices.instanceFamilyList[0] || 'N1';
+  const vCpuCount = config.vCpuCount || choices.vCpuList[0];
+  const memoryList = choices.memoryList.length
+    ? choices.memoryList
+    : vCpuCount
+    ? customInstanceBuilderService.generateValidMemoryListForVCpuCount(instanceFamily, vCpuCount)
+    : [];
+
+  return {
+    extendedMemory: Boolean(config.extendedMemory),
+    instanceFamily,
+    memory: config.memory || memoryList[0],
+    vCpuCount,
+  };
+}
+
+function getChoices(command: any, config: Partial<ICustomInstanceConfig>) {
+  const customInstanceTypes = command.backingData.customInstanceTypes || {};
+  const location = command.regional ? command.region : command.zone;
+  const locationToInstanceTypesMap =
+    command.backingData.credentialsKeyedByAccount?.[command.credentials]?.locationToInstanceTypesMap;
+  const vCpuList =
+    customInstanceTypes.vCpuList ||
+    (location && locationToInstanceTypesMap
+      ? customInstanceBuilderService.generateValidVCpuListForLocation(location, locationToInstanceTypesMap)
+      : []);
+  const selectedVCpu = config.vCpuCount || vCpuList[0];
+
+  return {
+    instanceFamilyList:
+      customInstanceTypes.instanceFamilyList || customInstanceBuilderService.generateValidInstanceFamilyList(),
+    memoryList:
+      customInstanceTypes.memoryList ||
+      (selectedVCpu
+        ? customInstanceBuilderService.generateValidMemoryListForVCpuCount(config.instanceFamily || 'N1', selectedVCpu)
+        : []),
+    vCpuList,
+  };
+}
+
+function isExtendedMemory(instanceType: string | null) {
+  return Boolean(instanceType && instanceType.endsWith('-ext'));
+}
+
+function stripExtendedMemorySuffix(instanceType: string) {
+  return isExtendedMemory(instanceType) ? instanceType.replace(/-ext$/, '') : instanceType;
+}

package/src/serverGroup/configure/wizard/hiddenMetadataKeys.value.js

@@ -1,15 +1,10 @@
 'use strict';
 
-import { module } from 'angular';
-
-export const GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_HIDDENMETADATAKEYS_VALUE =
-  'spinnaker.deck.gce.serverGroup.hiddenMetadataKeys.value';
-export const name = GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_HIDDENMETADATAKEYS_VALUE; // for backwards compatibility
-module(GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_HIDDENMETADATAKEYS_VALUE, []).value('gceServerGroupHiddenMetadataKeys', [
+export const GCE_SERVER_GROUP_HIDDEN_METADATA_KEYS = [
   'load-balancer-names',
   'global-load-balancer-names',
   'backend-service-names',
   'load-balancing-policy',
   'select-zones',
   'customUserData',
-]);
+];

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

@@ -0,0 +1,5 @@
+export * from './GceServerGroupWizard.types';
+export * from './GceServerGroupWizard.helpers';
+export * from './GceServerGroupWizardAdapter';
+export * from './GceServerGroupWizardPage';
+export * from './pages';