@spinnaker/google 2026.2.2 → 2026.3.0

package/src/autoscalingPolicy/GceAutoscalingPolicyWriter.ts

@@ -0,0 +1,101 @@
+import type { Application, IJob, ITask } from '@spinnaker/core';
+import { TaskExecutor } from '@spinnaker/core';
+
+import type { IGceAutoscalingPolicy } from './IGceAutoscalingPolicy';
+import type { IGceAutoHealingPolicy } from '../domain';
+
+interface IGcePolicyServerGroupIdentity {
+  account: string;
+  name: string;
+}
+
+export type IGcePolicyServerGroup = IGcePolicyServerGroupIdentity &
+  ({ region: string; zone?: string } | { region?: undefined; zone: string });
+
+export interface IGcePolicyTaskParams {
+  interestingHealthProviderNames?: string[];
+  reason?: string;
+}
+
+interface IGcePolicyJob extends IJob {
+  cloudProvider: 'gce';
+  credentials: string;
+  region: string;
+  serverGroupName: string;
+  type: 'upsertScalingPolicy' | 'deleteScalingPolicy';
+  autoscalingPolicy?: IGceAutoscalingPolicy;
+  autoHealingPolicy?: IGceAutoHealingPolicy;
+  deleteAutoHealingPolicy?: true;
+  interestingHealthProviderNames?: string[];
+  reason?: string;
+}
+
+function policyJob(serverGroup: IGcePolicyServerGroup, type: IGcePolicyJob['type']): IGcePolicyJob {
+  return {
+    type,
+    cloudProvider: 'gce',
+    credentials: serverGroup.account,
+    region: serverGroup.region ?? serverGroup.zone,
+    serverGroupName: serverGroup.name,
+  };
+}
+
+function supportedAutoHealingPolicy(policy: IGceAutoHealingPolicy): IGceAutoHealingPolicy {
+  // This is the final task boundary: legacy server responses can still carry fields that
+  // stable Compute v1 no longer accepts, so assemble the outbound contract explicitly.
+  const supported: IGceAutoHealingPolicy = {};
+  (['healthCheck', 'healthCheckKind', 'healthCheckUrl', 'initialDelaySec'] as const).forEach((field) => {
+    if (policy[field] !== undefined) {
+      (supported as any)[field] = policy[field];
+    }
+  });
+  return supported;
+}
+
+export class GceAutoscalingPolicyWriter {
+  public static upsertAutoscalingPolicy(
+    application: Application,
+    serverGroup: IGcePolicyServerGroup,
+    autoscalingPolicy: IGceAutoscalingPolicy,
+    params: IGcePolicyTaskParams = {},
+  ): Promise<ITask> {
+    return TaskExecutor.executeTask({
+      application,
+      description: `Upsert scaling policy ${serverGroup.name}`,
+      job: [{ ...policyJob(serverGroup, 'upsertScalingPolicy'), autoscalingPolicy, ...params }],
+    });
+  }
+
+  public static deleteAutoscalingPolicy(application: Application, serverGroup: IGcePolicyServerGroup): Promise<ITask> {
+    return TaskExecutor.executeTask({
+      application,
+      description: `Delete scaling policy ${serverGroup.name}`,
+      job: [policyJob(serverGroup, 'deleteScalingPolicy')],
+    });
+  }
+
+  public static upsertAutoHealingPolicy(
+    application: Application,
+    serverGroup: IGcePolicyServerGroup,
+    autoHealingPolicy: IGceAutoHealingPolicy,
+  ): Promise<ITask> {
+    return TaskExecutor.executeTask({
+      application,
+      description: `Upsert autohealing policy ${serverGroup.name}`,
+      job: [
+        {
+          ...policyJob(serverGroup, 'upsertScalingPolicy'),
+          autoHealingPolicy: supportedAutoHealingPolicy(autoHealingPolicy),
+        },
+      ],
+    });
+  }
+
+  public static deleteAutoHealingPolicy(application: Application, serverGroup: IGcePolicyServerGroup): Promise<ITask> {
+    return TaskExecutor.executeTask({
+      application,
+      description: `Delete autohealing policy ${serverGroup.name}`,
+      job: [{ ...policyJob(serverGroup, 'deleteScalingPolicy'), deleteAutoHealingPolicy: true }],
+    });
+  }
+}

package/src/autoscalingPolicy/IGceAutoscalingPolicy.ts

@@ -1,6 +1,13 @@
 export interface IGceAutoscalingPolicy {
-  cpuUtilization: IGceAutoscalingCpuUtilization;
-  scaleInControl: IGceScaleInControl;
+  minNumReplicas?: number;
+  maxNumReplicas?: number;
+  coolDownPeriodSec?: number;
+  mode?: 'ON' | 'OFF' | 'ONLY_SCALE_OUT';
+  cpuUtilization?: IGceAutoscalingCpuUtilization;
+  loadBalancingUtilization?: IGceAutoscalingUtilization;
+  customMetricUtilizations?: IGceAutoscalingCustomMetric[];
+  scaleInControl?: IGceScaleInControl;
+  scalingSchedules?: IGceScalingSchedule[];
 }
 
 export interface IGceScaleInControl {
@@ -16,6 +23,34 @@ export interface IGceAutoscalingCpuUtilization {
   utilizationTarget?: number;
 }
 
+export interface IGceAutoscalingUtilization {
+  utilizationTarget?: number;
+}
+
+export type GceUtilizationTargetType = 'GAUGE' | 'DELTA_PER_SECOND' | 'DELTA_PER_MINUTE';
+export type GceMetricExportScope = 'TIME_SERIES_PER_INSTANCE' | 'SINGLE_TIME_SERIES_PER_GROUP';
+export type GceScalingPolicyType = 'UTILIZATION_TARGET' | 'SINGLE_INSTANCE_ASSIGNMENT';
+
+export interface IGceAutoscalingCustomMetric {
+  metric?: string;
+  filter?: string;
+  metricExportScope?: GceMetricExportScope;
+  scalingpolicy?: GceScalingPolicyType;
+  singleInstanceAssignment?: number;
+  utilizationTarget?: number;
+  utilizationTargetType?: GceUtilizationTargetType;
+}
+
+export interface IGceScalingSchedule {
+  scheduleName?: string;
+  scheduleDescription?: string;
+  enabled?: boolean;
+  minimumRequiredInstances?: number;
+  scheduleCron?: string;
+  timezone?: string;
+  duration?: number;
+}
+
 export enum GcePredictiveMethod {
   NONE = 'NONE',
   STANDARD = 'OPTIMIZE_AVAILABILITY',

package/src/autoscalingPolicy/index.ts

@@ -1,2 +1,4 @@
 export * from './IGceAutoscalingPolicy';
 export * from './GceAutoScalingFieldLayout';
+export * from './GceAutoscalingPolicyWriter';
+export * from './GceAutoscalingPolicyEditor';

package/src/cache/cacheConfigurer.service.js

@@ -1,31 +1,39 @@
 'use strict';
 
-import { module } from 'angular';
-import { GCE_ADDRESS_READER } from '../address/address.reader';
-
-import { GOOGLE_BACKENDSERVICE_BACKENDSERVICE_READER } from '../backendService/backendService.reader';
-import { GCE_HEALTH_CHECK_READER } from '../healthCheck/healthCheck.read.service';
-
-export const GOOGLE_CACHE_CACHECONFIGURER_SERVICE = 'spinnaker.gce.cache.initializer';
-export const name = GOOGLE_CACHE_CACHECONFIGURER_SERVICE; // for backwards compatibility
-module(GOOGLE_CACHE_CACHECONFIGURER_SERVICE, [
-  GOOGLE_BACKENDSERVICE_BACKENDSERVICE_READER,
-  GCE_ADDRESS_READER,
-  GCE_HEALTH_CHECK_READER,
-]).factory('gceCacheConfigurer', [
-  'gceAddressReader',
-  'gceBackendServiceReader',
-  'gceCertificateReader',
-  'gceHealthCheckReader',
-  function (gceAddressReader, gceBackendServiceReader, gceCertificateReader, gceHealthCheckReader) {
+import { InfrastructureCaches, REST, SearchService } from '@spinnaker/core';
+
+import { GceCertificateReader } from '../certificate/certificate.reader';
+import { GceHealthCheckReader } from '../healthCheck/healthCheck.read.service';
+
+export class GceCacheConfigurer {
+  constructor() {
+    const gceCertificateReader = new GceCertificateReader();
+    const gceHealthCheckReader = new GceHealthCheckReader();
+    const listAddresses = () =>
+      SearchService.search({ q: '', type: 'addresses', allowShortQuery: 'true' }, InfrastructureCaches.get('addresses'))
+        .then((searchResults) => {
+          if (searchResults && searchResults.results) {
+            return searchResults.results
+              .filter((result) => result.provider === 'gce')
+              .map((result) => ({ ...JSON.parse(result.address), account: result.account, region: result.region }));
+          }
+          return [];
+        })
+        .catch(() => []);
+    const listBackendServices = () =>
+      REST('/search')
+        .useCache(InfrastructureCaches.get('backendServices'))
+        .query({ q: '', type: 'backendServices', allowShortQuery: 'true' })
+        .get();
+
     const config = Object.create(null);
 
     config.addresses = {
-      initializers: [() => gceAddressReader.listAddresses()],
+      initializers: [listAddresses],
     };
 
     config.backendServices = {
-      initializers: [() => gceBackendServiceReader.listBackendServices()],
+      initializers: [listBackendServices],
     };
 
     config.certificates = {
@@ -37,5 +45,5 @@ module(GOOGLE_CACHE_CACHECONFIGURER_SERVICE, [
     };
 
     return config;
-  },
-]);
+  }
+}

package/src/certificate/certificate.reader.ts

@@ -1,5 +1,3 @@
-import { module } from 'angular';
-
 import type { ISearchResults } from '@spinnaker/core';
 import { InfrastructureCaches, SearchService } from '@spinnaker/core';
 
@@ -11,7 +9,7 @@ export interface IGceCertificate {
 }
 
 export class GceCertificateReader {
-  public listCertificates(): PromiseLike<IGceCertificate[]> {
+  public listCertificates(): Promise<IGceCertificate[]> {
     return SearchService.search<IGceCertificate>(
       { q: '', type: 'sslCertificates', allowShortQuery: 'true' },
       InfrastructureCaches.get('certificates'),
@@ -26,6 +24,3 @@ export class GceCertificateReader {
       .catch(() => []);
   }
 }
-
-export const GCE_CERTIFICATE_READER = 'spinnaker.gce.certificateReader.service';
-module(GCE_CERTIFICATE_READER, []).service('gceCertificateReader', GceCertificateReader);

package/src/common/xpnNaming.gce.service.js

@@ -1,17 +1,14 @@
 'use strict';
 
-import { module } from 'angular';
 import _ from 'lodash';
 
-export const GOOGLE_COMMON_XPNNAMING_GCE_SERVICE = 'spinnaker.gce.common.xpnNaming.service';
-export const name = GOOGLE_COMMON_XPNNAMING_GCE_SERVICE; // for backwards compatibility
-module(GOOGLE_COMMON_XPNNAMING_GCE_SERVICE, []).factory('gceXpnNamingService', function () {
-  const deriveProjectId = (resourceWithSelfLink) => {
+export class GceXpnNamingService {
+  deriveProjectId = (resourceWithSelfLink) => {
     const pathSegments = resourceWithSelfLink.selfLink.split('/');
     return pathSegments[pathSegments.indexOf('projects') + 1];
   };
 
-  const decorateXpnResourceIfNecessary = (projectId, xpnResource) => {
+  decorateXpnResourceIfNecessary = (projectId, xpnResource) => {
     if (!xpnResource) {
       return null;
     }
@@ -27,9 +24,4 @@ module(GOOGLE_COMMON_XPNNAMING_GCE_SERVICE, []).factory('gceXpnNamingService', f
       return xpnResourceName;
     }
   };
-
-  return {
-    deriveProjectId,
-    decorateXpnResourceIfNecessary,
-  };
-});
+}

package/src/domain/autoHealingPolicy.ts

@@ -5,10 +5,4 @@ export interface IGceAutoHealingPolicy {
   healthCheckKind?: IGceHealthCheckKind; // used by Clouddriver to disambiguate health checks
   healthCheckUrl?: string; // used by Deck as unique ID
   initialDelaySec?: number;
-  maxUnavailable?: IMaxUnavailable;
-}
-
-export interface IMaxUnavailable {
-  fixed?: number;
-  percent?: number;
 }

package/src/domain/serverGroup.ts

@@ -1,8 +1,33 @@
 import type { IServerGroup } from '@spinnaker/core';
 
 import type { IGceAutoHealingPolicy } from './autoHealingPolicy';
+import type { IGceAutoscalingPolicy } from '../autoscalingPolicy';
+
+export interface IGceInstanceSelection {
+  rank?: number;
+  machineTypes: string[];
+}
+
+/**
+ * Named map of flexibility selections. Keys are selection names; values carry optional
+ * preference rank and one or more machine types. Rank may be omitted for equal preference.
+ */
+export interface IGceInstanceFlexibilityPolicy {
+  instanceSelections: { [selectionName: string]: IGceInstanceSelection };
+}
+
+export interface IGceDistributionPolicy {
+  zones?: string[];
+  targetShape?: string;
+}
 
 // TODO(dpeach): fill in the remaining GCE specific properties.
 export interface IGceServerGroup extends IServerGroup {
   autoHealingPolicy?: IGceAutoHealingPolicy;
+  autoscalingMessages?: string[];
+  autoscalingPolicy?: IGceAutoscalingPolicy;
+  distributionPolicy?: IGceDistributionPolicy;
+  instanceFlexibilityPolicy?: IGceInstanceFlexibilityPolicy;
+  selectZones?: boolean;
+  regional?: boolean;
 }