@spinnaker/google 2026.2.2 → 2026.3.0

package/src/loadBalancer/configure/common/gceLoadBalancerSubmission.spec.ts

@@ -0,0 +1,297 @@
+import { normalizeGceLoadBalancerCommand } from './gceLoadBalancerModels';
+import { buildGceLoadBalancerJobs, submitGceLoadBalancerCommand } from './gceLoadBalancerSubmission';
+
+describe('GCE load balancer submission', () => {
+  it('builds directly executable HTTP jobs for every listener with complete backend objects', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendServices: [
+          {
+            backends: [{ serverGroupUrl: 'projects/test/zones/europe-west1-b/instanceGroups/default-group' }],
+            enableCDN: false,
+            healthCheck: 'default-check',
+            name: 'default-backend',
+            portName: 'http',
+            sessionAffinity: 'NONE',
+          },
+          {
+            backends: [],
+            healthCheck: 'api-check',
+            name: 'api-backend',
+            portName: 'api',
+            sessionAffinity: 'CLIENT_IP',
+          },
+        ],
+        defaultService: 'default-backend',
+        healthChecks: [
+          {
+            checkIntervalSec: 10,
+            healthCheckType: 'HTTP',
+            healthyThreshold: 2,
+            name: 'default-check',
+            port: 80,
+            requestPath: '/health',
+            timeoutSec: 5,
+            unhealthyThreshold: 3,
+          },
+          {
+            checkIntervalSec: 15,
+            healthCheckType: 'HTTPS',
+            healthyThreshold: 2,
+            name: 'api-check',
+            port: 443,
+            requestPath: '/ready',
+            timeoutSec: 5,
+            unhealthyThreshold: 3,
+          },
+        ],
+        hostRules: [
+          {
+            hostPatterns: ['api.example.com', 'api.internal.example.com'],
+            pathMatcher: {
+              defaultService: 'default-backend',
+              pathRules: [{ backendService: 'api-backend', paths: ['/v1', '/v2'] }],
+            },
+          },
+        ],
+        listeners: [
+          { ipAddress: '203.0.113.10', name: 'app-http', port: 80, protocol: 'HTTP' },
+          { certificate: 'app-cert', ipAddress: '203.0.113.10', name: 'app-https', port: 443, protocol: 'HTTPS' },
+        ],
+        loadBalancerType: 'HTTP',
+        name: 'app-main',
+      },
+      'create',
+    );
+
+    const jobs = buildGceLoadBalancerJobs(command);
+
+    const defaultHealthCheck = {
+      checkIntervalSec: 10,
+      healthCheckType: 'HTTP',
+      healthyThreshold: 2,
+      name: 'default-check',
+      port: 80,
+      requestPath: '/health',
+      timeoutSec: 5,
+      unhealthyThreshold: 3,
+    };
+    const apiHealthCheck = {
+      checkIntervalSec: 15,
+      healthCheckType: 'HTTPS',
+      healthyThreshold: 2,
+      name: 'api-check',
+      port: 443,
+      requestPath: '/ready',
+      timeoutSec: 5,
+      unhealthyThreshold: 3,
+    };
+    const defaultService = {
+      backends: [{ serverGroupUrl: 'projects/test/zones/europe-west1-b/instanceGroups/default-group' }],
+      enableCDN: false,
+      healthCheck: defaultHealthCheck,
+      name: 'default-backend',
+      portName: 'http',
+      sessionAffinity: 'NONE',
+    };
+    const apiService = {
+      backends: [],
+      healthCheck: apiHealthCheck,
+      name: 'api-backend',
+      portName: 'api',
+      sessionAffinity: 'CLIENT_IP',
+    };
+    const common = {
+      cloudProvider: 'gce',
+      credentials: 'account-a',
+      defaultService,
+      hostRules: [
+        {
+          hostPatterns: ['api.example.com'],
+          pathMatcher: {
+            defaultService,
+            pathRules: [{ backendService: apiService, paths: ['/v1', '/v2'] }],
+          },
+        },
+        {
+          hostPatterns: ['api.internal.example.com'],
+          pathMatcher: {
+            defaultService,
+            pathRules: [{ backendService: apiService, paths: ['/v1', '/v2'] }],
+          },
+        },
+      ],
+      ipAddress: '203.0.113.10',
+      ipProtocol: 'TCP',
+      loadBalancerType: 'HTTP',
+      provider: 'gce',
+      region: 'global',
+      type: 'upsertLoadBalancer',
+      urlMapName: 'app-main',
+    };
+    expect(jobs).toEqual([
+      {
+        ...common,
+        certificate: null,
+        loadBalancerName: 'app-http',
+        name: 'app-http',
+        portRange: '80',
+      },
+      {
+        ...common,
+        certificate: 'app-cert',
+        loadBalancerName: 'app-https',
+        name: 'app-https',
+        portRange: '443',
+      },
+    ]);
+  });
+
+  it('computes listener removals and the original backend service diff for edits', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        defaultService: {
+          backends: [],
+          healthCheck: 'default-check',
+          name: 'default-backend',
+        },
+        healthChecks: [
+          { healthCheckType: 'HTTP', name: 'default-check', port: 80 },
+          { healthCheckType: 'HTTP', name: 'removed-check', port: 8080 },
+        ],
+        hostRules: [
+          {
+            hostPatterns: ['old.example.com'],
+            pathMatcher: {
+              defaultService: {
+                backends: [],
+                healthCheck: 'default-check',
+                name: 'default-backend',
+              },
+              pathRules: [
+                {
+                  backendService: {
+                    backends: [{ serverGroupUrl: 'projects/test/zones/europe-west1-b/instanceGroups/removed-group' }],
+                    healthCheck: 'removed-check',
+                    name: 'removed-backend',
+                  },
+                  paths: ['/old'],
+                },
+              ],
+            },
+          },
+        ],
+        listeners: [
+          { name: 'app-http', port: 80 },
+          { certificate: 'app-cert', name: 'app-https', port: 443 },
+        ],
+        loadBalancerType: 'HTTP',
+        urlMapName: 'app-main',
+      },
+      'edit',
+    );
+    command.listeners = command.listeners.filter(({ name }) => name === 'app-http');
+    command.backendServices = command.backendServices.filter(({ name }) => name === 'default-backend');
+    command.healthChecks = command.healthChecks.filter(({ name }) => name === 'default-check');
+    command.hostRules = [];
+
+    const [job] = buildGceLoadBalancerJobs(command);
+
+    expect(job.listenersToDelete).toEqual(['app-https']);
+    expect(job.backendServiceDiff).toEqual([
+      {
+        backends: [{ serverGroupUrl: 'projects/test/zones/europe-west1-b/instanceGroups/removed-group' }],
+        healthCheck: { healthCheckType: 'HTTP', name: 'removed-check', port: 8080 },
+        name: 'removed-backend',
+      },
+    ]);
+  });
+
+  it('returns INTERNAL_MANAGED operation commands to Orca in pipeline mode without executing a task', () => {
+    const command = normalizeGceLoadBalancerCommand(
+      {
+        account: 'account-a',
+        backendServices: [
+          {
+            backends: [],
+            healthCheck: 'default-check',
+            name: 'default-backend',
+          },
+        ],
+        defaultService: 'default-backend',
+        healthChecks: [{ healthCheckType: 'HTTP', name: 'default-check', port: 80 }],
+        listeners: [
+          { ipAddress: '10.0.0.10', name: 'internal-http', port: 80, protocol: 'HTTP', subnet: 'subnet-a' },
+          { ipAddress: '10.0.0.11', name: 'internal-api', port: 8080, protocol: 'HTTP', subnet: 'subnet-a' },
+        ],
+        loadBalancerType: 'INTERNAL_MANAGED',
+        name: 'app-internal',
+        network: 'network-a',
+        region: 'europe-west1',
+        subnet: 'subnet-a',
+      },
+      'pipeline',
+    );
+    const executeTask = jasmine.createSpy('executeTask');
+
+    const result = submitGceLoadBalancerCommand(command, { application: {} as any, executeTask });
+
+    expect(result).toEqual(buildGceLoadBalancerJobs(command));
+    expect((result as any[]).map(({ loadBalancerName }) => loadBalancerName)).toEqual([
+      'internal-http',
+      'internal-api',
+    ]);
+    expect((result as any[])[0]).toEqual(
+      jasmine.objectContaining({
+        ipProtocol: 'TCP',
+        loadBalancerName: 'internal-http',
+        network: 'network-a',
+        portRange: '80',
+        region: 'europe-west1',
+        subnet: 'subnet-a',
+        urlMapName: 'app-internal',
+      }),
+    );
+    expect((result as any[])[0].listeners).toBeUndefined();
+    expect((result as any[])[0].backendServices).toBeUndefined();
+    expect((result as any[])[0].healthChecks).toBeUndefined();
+    expect(executeTask).not.toHaveBeenCalled();
+  });
+
+  it('round-trips a flat HTTP pipeline operation without nesting or changing its identities', () => {
+    const operation = {
+      cloudProvider: 'gce',
+      credentials: 'account-a',
+      defaultService: {
+        backends: [],
+        healthCheck: { healthCheckType: 'HTTP', name: 'default-check', port: 80 },
+        name: 'default-backend',
+      },
+      hostRules: [],
+      ipAddress: 'address-a',
+      ipProtocol: 'TCP',
+      loadBalancerName: 'app-http',
+      loadBalancerType: 'HTTP',
+      name: 'app-http',
+      portRange: '80',
+      provider: 'gce',
+      region: 'global',
+      type: 'upsertLoadBalancer',
+      urlMapName: 'app-main',
+    };
+    const command = normalizeGceLoadBalancerCommand(operation, 'pipeline');
+
+    const result = submitGceLoadBalancerCommand(command, { application: {} as any });
+
+    expect(result).toEqual([
+      {
+        ...operation,
+        certificate: null,
+      },
+    ]);
+    expect(Array.isArray(result)).toBe(true);
+    expect((result as unknown[]).every((item) => !Array.isArray(item))).toBe(true);
+  });
+});

package/src/loadBalancer/configure/common/gceLoadBalancerSubmission.ts

@@ -0,0 +1,127 @@
+import { isEqual } from 'lodash';
+
+import type { Application, ITask, ITaskCommand } from '@spinnaker/core';
+import { TaskExecutor } from '@spinnaker/core';
+
+import type {
+  IGceLoadBalancerBackendService,
+  IGceLoadBalancerCommand,
+  IGceLoadBalancerHealthCheck,
+  IGceResourceReference,
+  IGceSerializedLoadBalancerCommand,
+} from './gceLoadBalancerModels';
+import { serializeGceLoadBalancerCommand } from './gceLoadBalancerModels';
+
+export interface IGceLoadBalancerSubmissionDependencies {
+  application: Application;
+  executeTask?: (taskCommand: ITaskCommand) => PromiseLike<ITask>;
+}
+
+export type GceLoadBalancerOperationList = IGceSerializedLoadBalancerCommand[];
+export type GceLoadBalancerSubmissionResult =
+  | IGceSerializedLoadBalancerCommand
+  | GceLoadBalancerOperationList
+  | Promise<ITask>;
+
+export function buildGceLoadBalancerJobs(command: IGceLoadBalancerCommand): GceLoadBalancerOperationList {
+  const serialized = serializeGceLoadBalancerCommand(command);
+  if (command.loadBalancerType !== 'HTTP' && command.loadBalancerType !== 'INTERNAL_MANAGED') {
+    return [serialized];
+  }
+
+  const {
+    backendServices: _backendServices,
+    healthChecks: _healthChecks,
+    hostRules: _hostRules,
+    listeners,
+    ...shared
+  } = serialized;
+  const backendServices = new Map(
+    command.backendServices.map((service) => [service.name, serializeBackendService(service, command.healthChecks)]),
+  );
+  const defaultService = resolveBackendService(command.defaultService, backendServices);
+  const hostRules = command.hostRules.flatMap((hostRule) =>
+    hostRule.hostPatterns.map((hostPattern) => ({
+      hostPatterns: [hostPattern],
+      pathMatcher: {
+        ...(hostRule.pathMatcher.defaultService
+          ? { defaultService: resolveBackendService(hostRule.pathMatcher.defaultService, backendServices) }
+          : {}),
+        pathRules: hostRule.pathMatcher.pathRules.map((pathRule) => ({
+          ...(pathRule.backendService
+            ? { backendService: resolveBackendService(pathRule.backendService, backendServices) }
+            : {}),
+          paths: [...pathRule.paths],
+        })),
+      },
+    })),
+  );
+
+  const jobs = ((listeners || []) as Array<Record<string, unknown>>).map((listener) => {
+    const name = String(listener.name);
+    return {
+      ...shared,
+      certificate: listener.certificate || null,
+      ...(defaultService ? { defaultService } : {}),
+      hostRules,
+      ipAddress: listener.ipAddress,
+      ipProtocol: 'TCP',
+      loadBalancerName: name,
+      name,
+      portRange: listener.portRange,
+      ...(listener.subnet ? { subnet: listener.subnet } : {}),
+      urlMapName: command.name,
+    } as IGceSerializedLoadBalancerCommand;
+  });
+
+  if (command.mode === 'edit' && command.original && jobs.length) {
+    const listenerNames = new Set(command.listeners.map(({ name }) => name));
+    const currentBackendServices = new Map(command.backendServices.map((service) => [service.name, service]));
+    jobs[0].listenersToDelete = command.original.listeners
+      .map(({ name }) => name)
+      .filter((name) => !listenerNames.has(name));
+    jobs[0].backendServiceDiff = command.original.backendServices
+      .filter((service) => !isEqual(service, currentBackendServices.get(service.name)))
+      .map((service) => serializeBackendService(service, command.original!.healthChecks));
+  }
+
+  return jobs;
+}
+
+function serializeBackendService(
+  service: IGceLoadBalancerBackendService,
+  healthChecks: IGceLoadBalancerHealthCheck[],
+): Record<string, unknown> {
+  const healthCheck = service.healthCheck
+    ? healthChecks.find(({ name }) => name === service.healthCheck?.name) || service.healthCheck
+    : undefined;
+  return {
+    ...service,
+    ...(healthCheck ? { healthCheck: { ...healthCheck } } : {}),
+  };
+}
+
+function resolveBackendService(
+  reference: IGceResourceReference | undefined,
+  services: Map<string, Record<string, unknown>>,
+): Record<string, unknown> | undefined {
+  return reference ? services.get(reference.name) || { ...reference } : undefined;
+}
+
+export function submitGceLoadBalancerCommand(
+  command: IGceLoadBalancerCommand,
+  { application, executeTask = TaskExecutor.executeTask }: IGceLoadBalancerSubmissionDependencies,
+): GceLoadBalancerSubmissionResult {
+  const jobs = buildGceLoadBalancerJobs(command);
+  if (command.mode === 'pipeline') {
+    return command.loadBalancerType === 'HTTP' || command.loadBalancerType === 'INTERNAL_MANAGED' ? jobs : jobs[0];
+  }
+
+  return Promise.resolve(
+    executeTask({
+      application,
+      description: `${command.mode === 'edit' ? 'Update' : 'Create'} Load Balancer: ${command.name}`,
+      job: jobs,
+    }),
+  );
+}

package/src/loadBalancer/configure/common/index.spec.ts

@@ -0,0 +1,17 @@
+import {
+  buildGceLoadBalancerJobs,
+  GCE_LOAD_BALANCER_CAPABILITIES,
+  GceLoadBalancerDataController,
+  normalizeGceLoadBalancerCommand,
+  useGceLoadBalancerData,
+} from '.';
+
+describe('GCE load balancer foundation exports', () => {
+  it('exposes the shared editor boundary', () => {
+    expect(buildGceLoadBalancerJobs).toBeDefined();
+    expect(GCE_LOAD_BALANCER_CAPABILITIES).toBeDefined();
+    expect(GceLoadBalancerDataController).toBeDefined();
+    expect(normalizeGceLoadBalancerCommand).toBeDefined();
+    expect(useGceLoadBalancerData).toBeDefined();
+  });
+});

package/src/loadBalancer/configure/common/index.ts

@@ -0,0 +1,4 @@
+export * from './gceLoadBalancerData';
+export * from './gceLoadBalancerModels';
+export * from './gceLoadBalancerSubmission';
+export * from './useGceLoadBalancerData';

package/src/loadBalancer/configure/common/useGceLoadBalancerData.spec.tsx

@@ -0,0 +1,78 @@
+import React from 'react';
+import { mount } from 'enzyme';
+
+import type { IGceLoadBalancerDataReaders, IGceLoadBalancerDataState } from './gceLoadBalancerData';
+import { useGceLoadBalancerData } from './useGceLoadBalancerData';
+
+describe('useGceLoadBalancerData', () => {
+  it('reloads data when the account changes', async () => {
+    const readers = testReaders();
+    const states: IGceLoadBalancerDataState[] = [];
+    const wrapper = mount(<Harness account="first" readers={readers} onState={(state) => states.push(state)} />);
+
+    await settle();
+    wrapper.setProps({ account: 'second' });
+    await settle();
+
+    expect(readers.regions.calls.allArgs()).toEqual([['first'], ['second']]);
+    expect(states[states.length - 1].status).toBe('ready');
+    wrapper.unmount();
+  });
+
+  it('does not publish a request result after unmount', async () => {
+    const regions = deferred<unknown[]>();
+    const readers = testReaders();
+    readers.regions.and.returnValue(regions.promise);
+    const onState = jasmine.createSpy('onState');
+    const wrapper = mount(<Harness account="test-account" readers={readers} onState={onState} />);
+    await settle();
+    const callsBeforeUnmount = onState.calls.count();
+
+    wrapper.unmount();
+    regions.resolve([{ name: 'late-region' }]);
+    await settle();
+
+    expect(onState.calls.count()).toBe(callsBeforeUnmount);
+  });
+});
+
+function Harness({
+  account,
+  readers,
+  onState,
+}: {
+  account: string;
+  readers: IGceLoadBalancerDataReaders;
+  onState: (state: IGceLoadBalancerDataState) => void;
+}) {
+  const state = useGceLoadBalancerData(account, readers);
+  React.useEffect(() => {
+    onState(state);
+  }, [state.status, state.data, state.error]);
+  return null;
+}
+
+function testReaders(): jasmine.SpyObj<IGceLoadBalancerDataReaders> {
+  return jasmine.createSpyObj<IGceLoadBalancerDataReaders>('readers', {
+    accounts: Promise.resolve([]),
+    addresses: Promise.resolve([]),
+    backendServices: Promise.resolve([]),
+    certificates: Promise.resolve([]),
+    healthChecks: Promise.resolve([]),
+    networks: Promise.resolve([]),
+    regions: Promise.resolve([]),
+    subnets: Promise.resolve([]),
+  });
+}
+
+function deferred<T>() {
+  let resolve: (value: T) => void;
+  const promise = new Promise<T>((resolver) => (resolve = resolver));
+  return { promise, resolve: resolve! };
+}
+
+async function settle(): Promise<void> {
+  await Promise.resolve();
+  await Promise.resolve();
+  await new Promise<void>((resolve) => setTimeout(resolve, 0));
+}

package/src/loadBalancer/configure/common/useGceLoadBalancerData.ts

@@ -0,0 +1,34 @@
+import { useEffect, useRef, useState } from 'react';
+
+import { GceLoadBalancerDataController, gceLoadBalancerDataReaders } from './gceLoadBalancerData';
+import type { IGceLoadBalancerDataReaders, IGceLoadBalancerDataState } from './gceLoadBalancerData';
+
+export interface IUseGceLoadBalancerDataResult extends IGceLoadBalancerDataState {
+  refresh: () => void;
+}
+
+export function useGceLoadBalancerData(
+  account: string,
+  readers: IGceLoadBalancerDataReaders = gceLoadBalancerDataReaders,
+): IUseGceLoadBalancerDataResult {
+  const controllerRef = useRef<GceLoadBalancerDataController | null>(null);
+  if (!controllerRef.current) {
+    controllerRef.current = new GceLoadBalancerDataController(readers);
+  }
+  const controller = controllerRef.current;
+  const [state, setState] = useState<IGceLoadBalancerDataState>(controller.getState());
+
+  useEffect(() => {
+    const unsubscribe = controller.subscribe(setState);
+    return () => {
+      unsubscribe();
+      controller.dispose();
+    };
+  }, [controller]);
+
+  useEffect(() => {
+    controller.load(account);
+  }, [account, controller]);
+
+  return { ...state, refresh: () => controller.load(account) };
+}