@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/details/rollback/GceRollbackServerGroupModal.tsx

@@ -0,0 +1,196 @@
+import React from 'react';
+
+import type { Application, IModalComponentProps, IServerGroup, IServerGroupJob, ITask } from '@spinnaker/core';
+import {
+  ModalClose,
+  noop,
+  PlatformHealthOverride,
+  ReactModal,
+  TaskMonitor,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+} from '@spinnaker/core';
+
+export interface IGceRollbackValues {
+  interestingHealthProviderNames?: string[];
+  reason?: string;
+  restoreServerGroupName?: string;
+}
+
+export interface IGceRollbackJob extends IServerGroupJob {
+  interestingHealthProviderNames?: string[];
+  platformHealthOnlyShowOverride?: boolean;
+  reason?: string;
+  rollbackContext: {
+    restoreServerGroupName?: string;
+    rollbackServerGroupName: string;
+  };
+  rollbackType: 'EXPLICIT';
+}
+
+export interface IGceRollbackServerGroupWriter {
+  rollbackServerGroup(serverGroup: IServerGroup, application: Application, command: IGceRollbackJob): Promise<ITask>;
+}
+
+export interface IGceRollbackServerGroupModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IServerGroup;
+  serverGroups: IServerGroup[];
+  serverGroupWriter: IGceRollbackServerGroupWriter;
+}
+
+interface IGceRollbackServerGroupModalState {
+  taskMonitor: TaskMonitor;
+  values: IGceRollbackValues;
+  verified: boolean;
+}
+
+export function buildGceRollbackJob(
+  application: Application,
+  serverGroup: IServerGroup,
+  values: IGceRollbackValues,
+): IGceRollbackJob {
+  return {
+    interestingHealthProviderNames: values.interestingHealthProviderNames,
+    platformHealthOnlyShowOverride: application.attributes?.platformHealthOnlyShowOverride,
+    reason: values.reason,
+    rollbackContext: {
+      restoreServerGroupName: values.restoreServerGroupName,
+      rollbackServerGroupName: serverGroup.name,
+    },
+    rollbackType: 'EXPLICIT',
+  };
+}
+
+export function getGceRollbackCandidates(
+  application: Application,
+  serverGroup: IServerGroup,
+  candidates: IServerGroup[],
+): IServerGroup[] {
+  return candidates
+    .filter((candidate) => {
+      const candidateApplication = candidate.app || candidate.moniker?.app;
+      return (
+        candidate.isDisabled === true &&
+        candidateApplication === application.name &&
+        candidate.cluster === serverGroup.cluster &&
+        candidate.account === serverGroup.account &&
+        candidate.region === serverGroup.region
+      );
+    })
+    .sort((a, b) => b.name.localeCompare(a.name));
+}
+
+export class GceRollbackServerGroupModal extends React.Component<
+  IGceRollbackServerGroupModalProps,
+  IGceRollbackServerGroupModalState
+> {
+  public static defaultProps: Partial<IGceRollbackServerGroupModalProps> = {
+    closeModal: noop,
+    dismissModal: noop,
+  };
+
+  public static show(props: IGceRollbackServerGroupModalProps): Promise<IGceRollbackJob> {
+    return ReactModal.show(GceRollbackServerGroupModal, props);
+  }
+
+  constructor(props: IGceRollbackServerGroupModalProps) {
+    super(props);
+    const { application, serverGroup } = props;
+    this.state = {
+      taskMonitor: new TaskMonitor({
+        application,
+        title: `Rollback ${serverGroup.name}`,
+        onDismiss: () => this.props.dismissModal(),
+        onTaskComplete: () => application.serverGroups.refresh(),
+      }),
+      values: {
+        interestingHealthProviderNames:
+          application.attributes?.platformHealthOnlyShowOverride && application.attributes?.platformHealthOnly
+            ? ['Google']
+            : undefined,
+      },
+      verified: false,
+    };
+  }
+
+  private close = (): void => this.props.dismissModal();
+
+  private isValid = (): boolean => this.state.verified && !!this.state.values.restoreServerGroupName;
+
+  private submit = (): void => {
+    if (!this.isValid()) {
+      return;
+    }
+
+    const { application, serverGroup, serverGroupWriter } = this.props;
+    const job = buildGceRollbackJob(application, serverGroup, this.state.values);
+    this.state.taskMonitor.submit(() => serverGroupWriter.rollbackServerGroup(serverGroup, application, job));
+  };
+
+  public render(): JSX.Element {
+    const { application, serverGroup, serverGroups } = this.props;
+    const { taskMonitor, values } = this.state;
+    const candidates = getGceRollbackCandidates(application, serverGroup, serverGroups);
+
+    return (
+      <>
+        <TaskMonitorWrapper monitor={taskMonitor} />
+        <ModalClose dismiss={this.close} />
+        <div className="modal-header">
+          <h4 className="modal-title">Rollback {serverGroup.name}</h4>
+        </div>
+        <div className="modal-body">
+          <form className="form-horizontal">
+            <div className="form-group">
+              <label className="col-sm-3 sm-label-right" htmlFor="gce-rollback-server-group">
+                Restore to
+              </label>
+              <div className="col-sm-6">
+                <select
+                  className="form-control input-sm"
+                  id="gce-rollback-server-group"
+                  onChange={(event) =>
+                    this.setState({ values: { ...values, restoreServerGroupName: event.target.value || undefined } })
+                  }
+                  value={values.restoreServerGroupName || ''}
+                >
+                  <option value="">Select...</option>
+                  {candidates.map((candidate) => (
+                    <option key={candidate.name} value={candidate.name}>
+                      {candidate.name}
+                    </option>
+                  ))}
+                </select>
+              </div>
+            </div>
+            {application.attributes?.platformHealthOnlyShowOverride && (
+              <PlatformHealthOverride
+                interestingHealthProviderNames={values.interestingHealthProviderNames}
+                onChange={(interestingHealthProviderNames) =>
+                  this.setState({ values: { ...values, interestingHealthProviderNames } })
+                }
+                platformHealthType="Google"
+                showHelpDetails={true}
+              />
+            )}
+            <TaskReason
+              reason={values.reason}
+              onChange={(reason) => this.setState({ values: { ...values, reason } })}
+            />
+          </form>
+        </div>
+        <div className="modal-footer">
+          <UserVerification account={serverGroup.account} onValidChange={(verified) => this.setState({ verified })} />
+          <button className="btn btn-default" onClick={this.close} type="button">
+            Cancel
+          </button>
+          <button className="btn btn-primary" disabled={!this.isValid()} onClick={this.submit} type="button">
+            Submit
+          </button>
+        </div>
+      </>
+    );
+  }
+}

package/src/serverGroup/details/stateful/UpdateBootImageButton.tsx

@@ -49,7 +49,7 @@ class UpdateBootImageModal extends React.Component<IUpdateBootImageModalProps, I
       taskMonitor: new TaskMonitor({
         application: props.application,
         title: 'Updating Boot Image',
-        modalInstance: TaskMonitor.modalInstanceEmulation(() => this.props.dismissModal()),
+        onDismiss: () => this.props.dismissModal(),
       }),
     };
   }

package/src/serverGroup/serverGroup.transformer.js

@@ -1,64 +1,83 @@
 'use strict';
 
-import { module } from 'angular';
-import { defaults } from 'lodash';
+import { defaults, get } from 'lodash';
 
-import { GCE_HTTP_LOAD_BALANCER_UTILS } from '../loadBalancer/httpLoadBalancerUtils.service';
+import { GceHttpLoadBalancerUtils } from '../loadBalancer/httpLoadBalancerUtils.service';
 
-export const GOOGLE_SERVERGROUP_SERVERGROUP_TRANSFORMER = 'spinnaker.gce.serverGroup.transformer';
-export const name = GOOGLE_SERVERGROUP_SERVERGROUP_TRANSFORMER; // for backwards compatibility
-module(GOOGLE_SERVERGROUP_SERVERGROUP_TRANSFORMER, [GCE_HTTP_LOAD_BALANCER_UTILS]).factory(
-  'gceServerGroupTransformer',
-  [
-    'gceHttpLoadBalancerUtils',
-    function (gceHttpLoadBalancerUtils) {
-      function normalizeServerGroup(serverGroup, application) {
-        return application
-          .getDataSource('loadBalancers')
-          .ready()
-          .then(() => {
-            if (serverGroup.loadBalancers) {
-              // At this point, the HTTP(S) load balancers have been normalized (listener names mapped to URL map names).
-              // Our server groups' lists of load balancer names still need to make this mapping.
-              serverGroup.loadBalancers = gceHttpLoadBalancerUtils.normalizeLoadBalancerNamesForAccount(
-                serverGroup.loadBalancers,
-                serverGroup.account,
-                application.getDataSource('loadBalancers').data,
-              );
-            }
-            return serverGroup;
-          });
+export class GceServerGroupTransformer {
+  constructor() {
+    const gceHttpLoadBalancerUtils = new GceHttpLoadBalancerUtils();
+    function normalizeServerGroup(serverGroup, application) {
+      return application
+        .getDataSource('loadBalancers')
+        .ready()
+        .then(() => {
+          if (serverGroup.loadBalancers) {
+            // At this point, the HTTP(S) load balancers have been normalized (listener names mapped to URL map names).
+            // Our server groups' lists of load balancer names still need to make this mapping.
+            serverGroup.loadBalancers = gceHttpLoadBalancerUtils.normalizeLoadBalancerNamesForAccount(
+              serverGroup.loadBalancers,
+              serverGroup.account,
+              application.getDataSource('loadBalancers').data,
+            );
+          }
+          return serverGroup;
+        });
+    }
+
+    function getAvailabilityZones(base) {
+      if (base.zone) {
+        return [base.zone];
       }
 
-      function convertServerGroupCommandToDeployConfiguration(base) {
-        const truncatedZones = base.backingData.filtered.truncatedZones;
+      return (
+        [
+          get(base, 'backingData.filtered.truncatedZones'),
+          get(base, ['availabilityZones', base.region]),
+          get(base, 'distributionPolicy.zones'),
+        ].find((zones) => Array.isArray(zones) && zones.length) || []
+      );
+    }
 
-        // use defaults to avoid copying the backingData, which is huge and expensive to copy over
-        const command = defaults({ backingData: [], viewState: [] }, base);
-        if (base.viewState.mode !== 'clone') {
-          delete command.source;
-        }
-        // We took this approach to avoid a breaking change to existing pipelines.
-        command.disableTraffic = !command.enableTraffic;
-        command.cloudProvider = 'gce';
-        command.availabilityZones = {};
-        command.availabilityZones[command.region] = base.zone ? [base.zone] : truncatedZones;
-        command.account = command.credentials;
-        delete command.viewState;
-        delete command.backingData;
-        delete command.selectedProvider;
-        delete command.implicitSecurityGroups;
-        delete command.enableTraffic;
-        delete command.providerType;
-        delete command.enableAutoHealing;
+    function convertServerGroupCommandToDeployConfiguration(base) {
+      // use defaults to avoid copying the backingData, which is huge and expensive to copy over
+      const command = defaults({ backingData: [], viewState: [] }, base);
+      if (base.viewState.mode !== 'clone') {
+        delete command.source;
+      }
+      // We took this approach to avoid a breaking change to existing pipelines.
+      command.disableTraffic = !command.enableTraffic;
+      command.cloudProvider = 'gce';
+      command.availabilityZones = {};
+      command.availabilityZones[command.region] = getAvailabilityZones(base);
+      command.account = command.credentials;
+      delete command.viewState;
+      delete command.backingData;
+      delete command.selectedProvider;
+      delete command.implicitSecurityGroups;
+      delete command.enableTraffic;
+      delete command.providerType;
+      delete command.enableAutoHealing;
+      delete command.partnerMetadata;
 
-        return command;
+      if (command.autoHealingPolicy) {
+        command.autoHealingPolicy = ['healthCheck', 'healthCheckKind', 'healthCheckUrl', 'initialDelaySec'].reduce(
+          (supportedPolicy, field) => {
+            if (command.autoHealingPolicy[field] !== undefined) {
+              supportedPolicy[field] = command.autoHealingPolicy[field];
+            }
+            return supportedPolicy;
+          },
+          {},
+        );
       }
 
-      return {
-        convertServerGroupCommandToDeployConfiguration: convertServerGroupCommandToDeployConfiguration,
-        normalizeServerGroup: normalizeServerGroup,
-      };
-    },
-  ],
-);
+      return command;
+    }
+
+    return {
+      convertServerGroupCommandToDeployConfiguration: convertServerGroupCommandToDeployConfiguration,
+      normalizeServerGroup: normalizeServerGroup,
+    };
+  }
+}

package/src/serverGroup/serverGroup.transformer.spec.js

@@ -1,24 +1,18 @@
 'use strict';
 
+import { GceServerGroupTransformer } from './serverGroup.transformer';
+
 describe('gceServerGroupTransformer', () => {
-  let transformer, $q, $scope;
-  beforeEach(window.module(require('./serverGroup.transformer').name));
-
-  beforeEach(() => {
-    window.inject((_$q_, $rootScope, _gceServerGroupTransformer_) => {
-      $q = _$q_;
-      $scope = $rootScope.$new();
-      transformer = _gceServerGroupTransformer_;
-    });
-  });
+  let transformer;
 
   describe('normalize server group load balancers', () => {
     let app;
     beforeEach(() => {
+      transformer = new GceServerGroupTransformer();
       app = {
         getDataSource: () => {
           return {
-            ready: () => $q.resolve(),
+            ready: () => Promise.resolve(),
             data: [
               { name: 'network-load-balancer', account: 'my-google-account' },
               { name: 'internal-load-balancer', account: 'my-google-account' },
@@ -36,7 +30,7 @@ describe('gceServerGroupTransformer', () => {
       };
     });
 
-    it('should map listener names to url map names', function () {
+    it('should map listener names to url map names', async function () {
       const serverGroup = {
         account: 'my-google-account',
         loadBalancers: [
@@ -47,13 +41,94 @@ describe('gceServerGroupTransformer', () => {
         ],
       };
 
-      let normalizedServerGroup;
-      transformer.normalizeServerGroup(serverGroup, app).then((normalized) => (normalizedServerGroup = normalized));
-      $scope.$digest();
+      const normalizedServerGroup = await transformer.normalizeServerGroup(serverGroup, app);
       expect(normalizedServerGroup.loadBalancers.length).toBe(3);
       expect(normalizedServerGroup.loadBalancers.includes('url-map-name')).toEqual(true);
       expect(normalizedServerGroup.loadBalancers.includes('network-load-balancer')).toEqual(true);
       expect(normalizedServerGroup.loadBalancers.includes('internal-load-balancer')).toEqual(true);
     });
   });
+
+  describe('convert server group command to deploy configuration', () => {
+    beforeEach(() => {
+      transformer = new GceServerGroupTransformer();
+    });
+
+    it('uses existing availability zones when pipeline commands do not have backing data', () => {
+      const deployConfig = transformer.convertServerGroupCommandToDeployConfiguration({
+        availabilityZones: { 'us-central1': ['us-central1-a', 'us-central1-b'] },
+        capacity: { desired: 2, max: 2, min: 2 },
+        credentials: 'my-google-account',
+        enableTraffic: true,
+        instanceMetadata: {},
+        region: 'us-central1',
+        viewState: { mode: 'editPipeline' },
+      });
+
+      expect(deployConfig.availabilityZones).toEqual({ 'us-central1': ['us-central1-a', 'us-central1-b'] });
+      expect(deployConfig.account).toBe('my-google-account');
+      expect(deployConfig.backingData).toBeUndefined();
+    });
+
+    it('preserves instanceFlexibilityPolicy for pipeline edit/save round-trips', () => {
+      const flexibilityPolicy = {
+        instanceSelections: {
+          preferred: { machineTypes: ['n2-standard-8'] },
+          fallback: { rank: 2, machineTypes: ['e2-standard-8'] },
+        },
+      };
+      const command = {
+        credentials: 'test-account',
+        region: 'us-central1',
+        zone: 'us-central1-a',
+        enableTraffic: true,
+        instanceFlexibilityPolicy: flexibilityPolicy,
+        backingData: { filtered: { truncatedZones: ['us-central1-a'] } },
+        viewState: { mode: 'editPipeline' },
+      };
+
+      const deployConfig = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(deployConfig.instanceFlexibilityPolicy).toEqual(flexibilityPolicy);
+      expect(deployConfig.backingData).toBeUndefined();
+      expect(deployConfig.viewState).toBeUndefined();
+    });
+
+    it('preserves nested distribution and flexibility intent while stripping unsupported legacy fields', () => {
+      const flexibilityPolicy = {
+        instanceSelections: {
+          preferred: { machineTypes: ['n2-standard-8'] },
+        },
+      };
+      const deployConfig = transformer.convertServerGroupCommandToDeployConfiguration({
+        autoHealingPolicy: {
+          healthCheck: 'web-health-check',
+          healthCheckUrl: 'https://compute/healthChecks/web-health-check',
+          initialDelaySec: 0,
+          maxUnavailable: { fixed: 2 },
+        },
+        credentials: 'test-account',
+        distributionPolicy: { zones: ['us-central1-a'], targetShape: 'ANY_SINGLE_ZONE' },
+        enableTraffic: true,
+        instanceFlexibilityPolicy: flexibilityPolicy,
+        partnerMetadata: { legacy: true },
+        region: 'us-central1',
+        selectZones: false,
+        viewState: { mode: 'editPipeline' },
+      });
+
+      expect(deployConfig.distributionPolicy).toEqual({
+        zones: ['us-central1-a'],
+        targetShape: 'ANY_SINGLE_ZONE',
+      });
+      expect(deployConfig.selectZones).toBe(false);
+      expect(deployConfig.instanceFlexibilityPolicy).toEqual(flexibilityPolicy);
+      expect(deployConfig.partnerMetadata).toBeUndefined();
+      expect(deployConfig.autoHealingPolicy).toEqual({
+        healthCheck: 'web-health-check',
+        healthCheckUrl: 'https://compute/healthChecks/web-health-check',
+        initialDelaySec: 0,
+      });
+    });
+  });
 });

package/src/subnet/subnet.renderer.js

@@ -1,24 +1,23 @@
 'use strict';
 
-import { module } from 'angular';
 import _ from 'lodash';
 
 import { NetworkReader } from '@spinnaker/core';
 
-export const GOOGLE_SUBNET_SUBNET_RENDERER = 'spinnaker.gce.subnet.renderer';
-export const name = GOOGLE_SUBNET_SUBNET_RENDERER; // for backwards compatibility
-module(GOOGLE_SUBNET_SUBNET_RENDERER, []).factory('gceSubnetRenderer', function () {
-  let gceNetworks;
+export class GceSubnetRenderer {
+  constructor() {
+    this.gceNetworks = undefined;
 
-  NetworkReader.listNetworksByProvider('gce').then(function (networks) {
-    gceNetworks = networks;
-  });
+    NetworkReader.listNetworksByProvider('gce').then((networks) => {
+      this.gceNetworks = networks;
+    });
+  }
 
-  function render(serverGroup) {
+  render(serverGroup) {
     if (serverGroup.subnet) {
       return serverGroup.subnet;
     } else {
-      const autoCreateSubnets = _.chain(gceNetworks)
+      const autoCreateSubnets = _.chain(this.gceNetworks)
         .filter({ account: serverGroup.account, name: serverGroup.network })
         .map('autoCreateSubnets')
         .head()
@@ -27,8 +26,4 @@ module(GOOGLE_SUBNET_SUBNET_RENDERER, []).factory('gceSubnetRenderer', function
       return autoCreateSubnets ? '(Auto-select)' : '[none]';
     }
   }
-
-  return {
-    render: render,
-  };
-});
+}

package/src/validation/ApplicationNameValidator.spec.ts

@@ -0,0 +1,47 @@
+import { AccountService, ApplicationNameValidator, FirewallLabels } from '@spinnaker/core';
+
+import { GoogleApplicationNameValidator } from './ApplicationNameValidator';
+import '../gce.module';
+
+describe('Google application name validator', () => {
+  const validator = new GoogleApplicationNameValidator();
+
+  it('requires a leading letter followed only by letters or digits', () => {
+    expect(validator.validate('valid123')).toEqual({ errors: [], warnings: [] });
+    expect(validator.validate('1invalid-name').errors).toEqual([
+      'The application name must begin with a letter and must contain only letters or digits. No special characters are allowed.',
+    ]);
+  });
+
+  it('rejects application names longer than the Google resource maximum', () => {
+    expect(validator.validate('a'.repeat(64)).errors).toContain(
+      'The maximum length for an application in Google is 63 characters.',
+    );
+  });
+
+  it('warns as load-balancer, server-group, and firewall name space is exhausted', () => {
+    const loadBalancerWarnings = validator.validate('a'.repeat(35)).warnings.join(' ');
+    const serverGroupWarnings = validator.validate('a'.repeat(47)).warnings.join(' ');
+    const firewallWarnings = validator.validate('a'.repeat(61)).warnings.join(' ');
+
+    expect(loadBalancerWarnings).toContain(
+      'If you plan to include a stack or detail field for Google load balancers, you will only',
+    );
+    expect(serverGroupWarnings).toContain('Google server groups');
+    expect(firewallWarnings).toContain(`Google ${FirewallLabels.get('firewalls')}`);
+  });
+
+  it('is registered directly when the Google module is imported', async () => {
+    spyOn(AccountService, 'listProviders').and.returnValue(Promise.resolve(['gce']));
+
+    const result = await ApplicationNameValidator.validate('invalid-name', ['gce']);
+
+    expect(result.errors).toEqual([
+      {
+        cloudProvider: 'gce',
+        message:
+          'The application name must begin with a letter and must contain only letters or digits. No special characters are allowed.',
+      },
+    ]);
+  });
+});

package/src/validation/ApplicationNameValidator.ts

@@ -0,0 +1,89 @@
+import type { IApplicationNameValidator, IValidationResult } from '@spinnaker/core';
+import { ApplicationNameValidator, FirewallLabels } from '@spinnaker/core';
+
+export class GoogleApplicationNameValidator implements IApplicationNameValidator {
+  private validateSpecialCharacters(name: string, errors: string[]): void {
+    const pattern = /^([a-zA-Z][a-zA-Z0-9]*)?$/;
+    if (!pattern.test(name)) {
+      errors.push(
+        'The application name must begin with a letter and must contain only letters or digits. No ' +
+          'special characters are allowed.',
+      );
+    }
+  }
+
+  private validateLength(name: string, warnings: string[], errors: string[]): void {
+    const maxResourceNameLength = 63;
+    const maxLengthForLoadBalancers = maxResourceNameLength - 17;
+    const maxLengthForServerGroups = maxResourceNameLength - 10;
+
+    if (name.length > maxResourceNameLength) {
+      errors.push('The maximum length for an application in Google is 63 characters.');
+      return;
+    }
+
+    if (name.length > maxLengthForLoadBalancers - 12) {
+      if (name.length > maxLengthForLoadBalancers) {
+        warnings.push(`You will not be able to create a Google load balancer for this application if the
+            application's name is longer than ${maxLengthForLoadBalancers} characters (currently: ${name.length}
+          characters).`);
+      } else if (name.length >= maxLengthForLoadBalancers - 2) {
+        warnings.push(
+          'With separators ("-"), you will not be able to include a stack and detail field for ' +
+            'Google load balancers.',
+        );
+      } else {
+        const remaining = maxLengthForLoadBalancers - 2 - name.length;
+        warnings.push(`If you plan to include a stack or detail field for Google load balancers, you will only
+            have ~${remaining} characters to do so.`);
+      }
+    }
+
+    if (name.length > maxLengthForServerGroups - 12) {
+      if (name.length > maxLengthForServerGroups) {
+        warnings.push(`You will not be able to create a Google server group for this application if the
+            application's name is longer than ${maxLengthForServerGroups} characters (currently: ${name.length}
+            characters).`);
+      } else if (name.length >= maxLengthForServerGroups - 2) {
+        warnings.push(
+          'With separators ("-"), you will not be able to include a stack and detail field for ' +
+            'Google server groups.',
+        );
+      } else {
+        const remaining = maxLengthForServerGroups - 2 - name.length;
+        warnings.push(`If you plan to include a stack or detail field for Google server groups, you will only
+            have ~${remaining} characters to do so.`);
+      }
+    }
+
+    if (name.length > maxResourceNameLength - 12) {
+      if (name.length >= maxResourceNameLength - 2) {
+        warnings.push(
+          `With separators ("-"), you will not be able to include a stack and detail field for Google ${FirewallLabels.get(
+            'firewalls',
+          )}.`,
+        );
+      } else {
+        const remaining = maxResourceNameLength - 2 - name.length;
+        warnings.push(`If you plan to include a stack or detail field for Google ${FirewallLabels.get(
+          'firewalls',
+        )}, you will only
+            have ~${remaining} characters to do so.`);
+      }
+    }
+  }
+
+  public validate(name = ''): IValidationResult {
+    const warnings: string[] = [];
+    const errors: string[] = [];
+
+    if (name.length) {
+      this.validateSpecialCharacters(name, errors);
+      this.validateLength(name, warnings, errors);
+    }
+
+    return { warnings, errors };
+  }
+}
+
+ApplicationNameValidator.registerValidator('gce', new GoogleApplicationNameValidator());

package/dist/address/address.reader.d.ts

@@ -1,15 +0,0 @@
-export interface IGceAddress {
-    account?: string;
-    address: string;
-    creationTimestamp?: string;
-    description?: string;
-    id?: number;
-    kind?: string;
-    labelFingerprint?: string;
-    name?: string;
-    networkTier?: string;
-    region?: string;
-    selfLink?: string;
-    status?: string;
-}
-export declare const GCE_ADDRESS_READER = "spinnaker.gce.addressReader.service";