@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/configure/serverGroupConfiguration.service.js

@@ -1,109 +1,96 @@
 'use strict';
 
-import * as angular from 'angular';
 import _ from 'lodash';
 
-import {
-  AccountService,
-  CACHE_INITIALIZER_SERVICE,
-  LOAD_BALANCER_READ_SERVICE,
-  NetworkReader,
-  SECURITY_GROUP_READER,
-  SubnetReader,
-} from '@spinnaker/core';
+import { AccountService, InfrastructureCaches, NetworkReader, SubnetReader } from '@spinnaker/core';
 
 import { GCEProviderSettings } from '../../gce.settings';
-import { GCE_HEALTH_CHECK_READER } from '../../healthCheck/healthCheck.read.service';
+import { GceHealthCheckReader } from '../../healthCheck/healthCheck.read.service';
 import { getHealthCheckOptions } from '../../healthCheck/healthCheckUtils';
 import { GceImageReader } from '../../image';
-import { GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCEBUILDER_GCE_SERVICE } from './../../instance/custom/customInstanceBuilder.gce.service';
-import { GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE } from '../../instance/gceInstanceType.service';
-import { GCE_HTTP_LOAD_BALANCER_UTILS } from '../../loadBalancer/httpLoadBalancerUtils.service';
-import { LOAD_BALANCER_SET_TRANSFORMER } from '../../loadBalancer/loadBalancer.setTransformer';
+import { GceCustomInstanceBuilderService } from './../../instance/custom/customInstanceBuilder.gce.service';
+import { GceInstanceTypeService } from '../../instance/gceInstanceType.service';
+import { GceHttpLoadBalancerUtils } from '../../loadBalancer/httpLoadBalancerUtils.service';
+import { GceLoadBalancerSetTransformer } from '../../loadBalancer/loadBalancer.setTransformer';
 import { GceAcceleratorService } from './wizard/advancedSettings/gceAccelerator.service';
-import { GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_SECURITYGROUPS_TAGMANAGER_SERVICE } from './wizard/securityGroups/tagManager.service';
+import { GceTagManager } from './wizard/securityGroups/tagManager.service';
 
 export const GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE =
   'spinnaker.serverGroup.configure.gce.configuration.service';
 export const name = GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE; // for backwards compatibility
-angular
-  .module(GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE, [
-    LOAD_BALANCER_SET_TRANSFORMER,
-    SECURITY_GROUP_READER,
-    CACHE_INITIALIZER_SERVICE,
-    LOAD_BALANCER_READ_SERVICE,
-    GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE,
-    GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCEBUILDER_GCE_SERVICE,
-    GCE_HTTP_LOAD_BALANCER_UTILS,
-    GCE_HEALTH_CHECK_READER,
-    GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_SECURITYGROUPS_TAGMANAGER_SERVICE,
-  ])
-  .factory('gceServerGroupConfigurationService', [
-    'securityGroupReader',
-    'gceInstanceTypeService',
-    'cacheInitializer',
-    '$q',
-    'loadBalancerReader',
-    'gceCustomInstanceBuilderService',
-    'gceHttpLoadBalancerUtils',
-    'gceHealthCheckReader',
-    'gceTagManager',
-    'gceLoadBalancerSetTransformer',
-    function (
-      securityGroupReader,
-      gceInstanceTypeService,
-      cacheInitializer,
-      $q,
-      loadBalancerReader,
-      gceCustomInstanceBuilderService,
-      gceHttpLoadBalancerUtils,
-      gceHealthCheckReader,
-      gceTagManager,
-      gceLoadBalancerSetTransformer,
-    ) {
-      const persistentDiskTypes = ['pd-standard', 'pd-ssd', 'hyperdisk-balanced'];
-      const authScopes = [
-        'cloud-platform',
-        'userinfo.email',
-        'compute.readonly',
-        'compute',
-        'cloud.useraccounts.readonly',
-        'cloud.useraccounts',
-        'devstorage.read_only',
-        'devstorage.write_only',
-        'devstorage.full_control',
-        'taskqueue',
-        'bigquery',
-        'sqlservice.admin',
-        'datastore',
-        'logging.write',
-        'logging.read',
-        'logging.admin',
-        'monitoring.write',
-        'monitoring.read',
-        'monitoring',
-        'bigtable.data.readonly',
-        'bigtable.data',
-        'bigtable.admin',
-        'bigtable.admin.table',
-      ];
-
-      function configureCommand(application, command) {
-        return $q
-          .all([
-            AccountService.getCredentialsKeyedByAccount('gce'),
-            securityGroupReader.getAllSecurityGroups(),
-            NetworkReader.listNetworksByProvider('gce'),
-            SubnetReader.listSubnetsByProvider('gce'),
-            loadBalancerReader.listLoadBalancers('gce'),
-            loadAllImages(command.credentials),
-            gceInstanceTypeService.getAllTypesByRegion(),
-            $q.when(angular.copy(persistentDiskTypes)),
-            $q.when(angular.copy(authScopes)),
-            gceHealthCheckReader.listHealthChecks(),
-            AccountService.listAccounts('gce'),
-          ])
-          .then(function ([
+// EVEN remains for non-flex regional MIGs. Flexibility requires BALANCED, ANY, or ANY_SINGLE_ZONE.
+export const GCE_DISTRIBUTION_POLICY_TARGET_SHAPES = ['ANY', 'EVEN', 'BALANCED', 'ANY_SINGLE_ZONE'];
+export class GceServerGroupConfigurationService {
+  static requiresDeckRuntimeServices = true;
+
+  constructor(
+    promiseService = { all: (values) => Promise.all(values), resolve: (value) => Promise.resolve(value) },
+    runtimeServices,
+  ) {
+    const securityGroupReader = runtimeServices.securityGroupReader;
+    const loadBalancerReader = runtimeServices.loadBalancerReader;
+    const gceInstanceTypeService = new GceInstanceTypeService(promiseService);
+    const gceCustomInstanceBuilderService = new GceCustomInstanceBuilderService();
+    const gceHttpLoadBalancerUtils = new GceHttpLoadBalancerUtils();
+    const gceHealthCheckReader = new GceHealthCheckReader();
+    const gceTagManager = new GceTagManager();
+    const gceLoadBalancerSetTransformer = new GceLoadBalancerSetTransformer();
+    const persistentDiskTypes = ['pd-standard', 'pd-ssd', 'hyperdisk-balanced'];
+    const authScopes = [
+      'cloud-platform',
+      'userinfo.email',
+      'compute.readonly',
+      'compute',
+      'cloud.useraccounts.readonly',
+      'cloud.useraccounts',
+      'devstorage.read_only',
+      'devstorage.write_only',
+      'devstorage.full_control',
+      'taskqueue',
+      'bigquery',
+      'sqlservice.admin',
+      'datastore',
+      'logging.write',
+      'logging.read',
+      'logging.admin',
+      'monitoring.write',
+      'monitoring.read',
+      'monitoring',
+      'bigtable.data.readonly',
+      'bigtable.data',
+      'bigtable.admin',
+      'bigtable.admin.table',
+    ];
+
+    function configureCommand(application, command) {
+      return promiseService
+        .all([
+          AccountService.getCredentialsKeyedByAccount('gce'),
+          securityGroupReader.getAllSecurityGroups(),
+          NetworkReader.listNetworksByProvider('gce'),
+          SubnetReader.listSubnetsByProvider('gce'),
+          loadBalancerReader.listLoadBalancers('gce'),
+          loadAllImages(command.credentials),
+          gceInstanceTypeService.getAllTypesByRegion(),
+          promiseService.resolve(_.cloneDeep(persistentDiskTypes)),
+          promiseService.resolve(_.cloneDeep(authScopes)),
+          gceHealthCheckReader.listHealthChecks(),
+          AccountService.listAccounts('gce'),
+        ])
+        .then(function ([
+          credentialsKeyedByAccount,
+          securityGroups,
+          networks,
+          subnets,
+          loadBalancers,
+          allImages,
+          instanceTypes,
+          persistentDiskTypes,
+          authScopes,
+          healthChecks,
+          accounts,
+        ]) {
+          const backingData = {
             credentialsKeyedByAccount,
             securityGroups,
             networks,
@@ -115,666 +102,647 @@ angular
             authScopes,
             healthChecks,
             accounts,
-          ]) {
-            const backingData = {
-              credentialsKeyedByAccount,
-              securityGroups,
-              networks,
-              subnets,
-              loadBalancers,
-              allImages,
-              instanceTypes,
-              persistentDiskTypes,
-              authScopes,
-              healthChecks,
-              accounts,
-            };
-            let securityGroupReloader = $q.when(null);
-            let networkReloader = $q.when(null);
-            let healthCheckReloader = $q.when(null);
-            backingData.filtered = {};
-            backingData.distributionPolicyTargetShapes = getDistributionPolicyTargetShapes();
-            command.backingData = backingData;
-            configureImages(command);
-
-            if (command.securityGroups && command.securityGroups.length) {
-              // Verify all firewalls are accounted for; otherwise, try refreshing firewalls cache.
-              const securityGroupIds = _.map(getSecurityGroups(command), 'id');
-              if (_.intersection(command.securityGroups, securityGroupIds).length < command.securityGroups.length) {
-                securityGroupReloader = refreshSecurityGroups(command, true);
-              }
+          };
+          let securityGroupReloader = promiseService.resolve(null);
+          let networkReloader = promiseService.resolve(null);
+          let healthCheckReloader = promiseService.resolve(null);
+          backingData.filtered = {};
+          backingData.distributionPolicyTargetShapes = getDistributionPolicyTargetShapes();
+          command.backingData = backingData;
+          configureImages(command);
+
+          if (command.securityGroups && command.securityGroups.length) {
+            // Verify all firewalls are accounted for; otherwise, try refreshing firewalls cache.
+            const securityGroupIds = _.map(getSecurityGroups(command), 'id');
+            if (_.intersection(command.securityGroups, securityGroupIds).length < command.securityGroups.length) {
+              securityGroupReloader = refreshSecurityGroups(command, true);
             }
-            if (command.network) {
-              // Verify network is accounted for; otherwise, try refreshing networks cache.
-              const networkNames = getNetworkNames(command);
-              if (!networkNames.includes(command.network)) {
-                networkReloader = refreshNetworks(command);
-              }
+          }
+          if (command.network) {
+            // Verify network is accounted for; otherwise, try refreshing networks cache.
+            const networkNames = getNetworkNames(command);
+            if (!networkNames.includes(command.network)) {
+              networkReloader = refreshNetworks(command);
             }
+          }
 
-            if (command.autoScalingPolicy) {
-              command.enableAutoScaling = true;
-            }
+          if (command.autoScalingPolicy) {
+            command.enableAutoScaling = true;
+          }
 
-            if (command.autoHealingPolicy) {
-              command.enableAutoHealing = true;
-            }
-            if (_.has(command, 'autoHealingPolicy.healthCheck')) {
-              // Verify health check is accounted for; otherwise, try refreshing health checks cache.
-              const healthChecks = getHealthChecks(command);
-              if (!_.chain(healthChecks).map('selfLink').includes(command.autoHealingPolicy.healthCheckUrl).value()) {
-                healthCheckReloader = refreshHealthChecks(command, true);
-              }
+          if (command.autoHealingPolicy) {
+            command.enableAutoHealing = true;
+          }
+          if (_.has(command, 'autoHealingPolicy.healthCheck')) {
+            // Verify health check is accounted for; otherwise, try refreshing health checks cache.
+            const healthChecks = getHealthChecks(command);
+            if (!_.chain(healthChecks).map('selfLink').includes(command.autoHealingPolicy.healthCheckUrl).value()) {
+              healthCheckReloader = refreshHealthChecks(command, true);
             }
+          }
 
-            return $q.all([securityGroupReloader, networkReloader, healthCheckReloader]).then(() => {
-              gceTagManager.register(command);
-              attachEventHandlers(command);
-            });
+          return promiseService.all([securityGroupReloader, networkReloader, healthCheckReloader]).then(() => {
+            gceTagManager.register(command);
+            attachEventHandlers(command);
           });
+        });
+    }
+
+    function getDistributionPolicyTargetShapes() {
+      // EVEN remains for non-flex regional MIGs. Flexibility requires BALANCED, ANY, or
+      // ANY_SINGLE_ZONE (enforced in the configurer and clone validation).
+      return GCE_DISTRIBUTION_POLICY_TARGET_SHAPES.slice();
+    }
+
+    function configureDistributionPolicyTargetShape(command) {
+      const accountDetails = command.backingData.credentialsKeyedByAccount[command.credentials];
+      if (!command.distributionPolicy.targetShape) {
+        command.distributionPolicy.targetShape = 'EVEN';
       }
-
-      function getDistributionPolicyTargetShapes() {
-        return ['ANY', 'EVEN'];
+    }
+
+    function loadAllImages(account) {
+      return GceImageReader.findImages({
+        account: account,
+        provider: 'gce',
+        q: '*',
+      });
+    }
+
+    function configureInstanceTypes(command) {
+      const result = { dirty: {} };
+      if (command.region) {
+        const results = [result.dirty];
+
+        results.push(configureCustomInstanceTypes(command).dirty);
+        results.push(configureStandardInstanceTypes(command).dirty);
+
+        Object.assign(...results);
+      } else {
+        command.backingData.filtered.instanceTypes = [];
       }
+      return result;
+    }
 
-      function configureDistributionPolicyTargetShape(command) {
-        const accountDetails = command.backingData.credentialsKeyedByAccount[command.credentials];
-        if (!command.distributionPolicy.targetShape) {
-          command.distributionPolicy.targetShape = 'EVEN';
-        }
-      }
+    function configureCpuPlatforms(command) {
+      const result = { dirty: {} };
+      const filteredData = command.backingData.filtered;
+      const locationToCpuPlatformsMap =
+        command.backingData.credentialsKeyedByAccount[command.credentials].locationToCpuPlatformsMap;
 
-      function loadAllImages(account) {
-        return GceImageReader.findImages({
-          account: account,
-          provider: 'gce',
-          q: '*',
-        });
-      }
-
-      function configureInstanceTypes(command) {
-        const result = { dirty: {} };
-        if (command.region) {
-          const results = [result.dirty];
+      filteredData.cpuPlatforms = ['(Automatic)'];
 
-          results.push(configureCustomInstanceTypes(command).dirty);
-          results.push(configureStandardInstanceTypes(command).dirty);
+      const location = command.regional ? command.region : command.zone;
 
-          angular.extend(...results);
-        } else {
-          command.backingData.filtered.instanceTypes = [];
-        }
-        return result;
+      if (_.has(locationToCpuPlatformsMap, location)) {
+        filteredData.cpuPlatforms = _.concat(filteredData.cpuPlatforms, locationToCpuPlatformsMap[location]);
       }
 
-      function configureCpuPlatforms(command) {
-        const result = { dirty: {} };
-        const filteredData = command.backingData.filtered;
-        const locationToCpuPlatformsMap =
-          command.backingData.credentialsKeyedByAccount[command.credentials].locationToCpuPlatformsMap;
-
-        filteredData.cpuPlatforms = ['(Automatic)'];
+      if (!_.includes(filteredData.cpuPlatforms, command.minCpuPlatform)) {
+        delete command.minCpuPlatform;
+        result.dirty.minCpuPlatform = true;
+      }
+      return result;
+    }
 
-        const location = command.regional ? command.region : command.zone;
+    function configureStandardInstanceTypes(command) {
+      const c = command;
+      const result = { dirty: {} };
 
-        if (_.has(locationToCpuPlatformsMap, location)) {
-          filteredData.cpuPlatforms = _.concat(filteredData.cpuPlatforms, locationToCpuPlatformsMap[location]);
-        }
+      const locations = c.regional ? c.distributionPolicy.zones : [c.zone];
+      const { credentialsKeyedByAccount } = c.backingData;
+      const { locationToInstanceTypesMap } = credentialsKeyedByAccount[c.credentials];
 
-        if (!_.includes(filteredData.cpuPlatforms, command.minCpuPlatform)) {
-          delete command.minCpuPlatform;
-          result.dirty.minCpuPlatform = true;
-        }
+      if (locations.every((l) => !l)) {
         return result;
       }
 
-      function configureStandardInstanceTypes(command) {
-        const c = command;
-        const result = { dirty: {} };
-
-        const locations = c.regional ? c.distributionPolicy.zones : [c.zone];
-        const { credentialsKeyedByAccount } = c.backingData;
-        const { locationToInstanceTypesMap } = credentialsKeyedByAccount[c.credentials];
-
-        if (locations.every((l) => !l)) {
-          return result;
-        }
-
-        let filtered = gceInstanceTypeService.getAvailableTypesForLocations(locationToInstanceTypesMap, locations);
+      let filtered = gceInstanceTypeService.getAvailableTypesForLocations(locationToInstanceTypesMap, locations);
 
-        filtered = sortInstanceTypes(filtered);
-        const instanceType = c.instanceType;
-        if (_.every([instanceType, !_.includes(instanceType, 'custom-'), !_.includes(filtered, instanceType)])) {
-          result.dirty.instanceType = c.instanceType;
-          c.instanceType = null;
-        }
-        c.backingData.filtered.instanceTypes = filtered;
+      filtered = sortInstanceTypes(filtered);
+      const instanceType = c.instanceType;
+      if (_.every([instanceType, !_.includes(instanceType, 'custom-'), !_.includes(filtered, instanceType)])) {
+        result.dirty.instanceType = c.instanceType;
+        c.instanceType = null;
+      }
+      c.backingData.filtered.instanceTypes = filtered;
+      return result;
+    }
+
+    function configureCustomInstanceTypes(command) {
+      const c = command;
+      const result = { dirty: {} };
+      let vCpuCount = _.get(c, 'viewState.customInstance.vCpuCount');
+      const instanceFamily = _.get(c, 'viewState.customInstance.instanceFamily');
+      const memory = _.get(c, 'viewState.customInstance.memory');
+      const extendedMemory = _.get(c, 'viewState.customInstance.extendedMemory');
+      const { zone, regional, region } = c;
+      const { locationToInstanceTypesMap } = c.backingData.credentialsKeyedByAccount[c.credentials];
+      const location = regional ? region : zone;
+
+      if (!location) {
         return result;
       }
 
-      function configureCustomInstanceTypes(command) {
-        const c = command;
-        const result = { dirty: {} };
-        let vCpuCount = _.get(c, 'viewState.customInstance.vCpuCount');
-        const instanceFamily = _.get(c, 'viewState.customInstance.instanceFamily');
-        const memory = _.get(c, 'viewState.customInstance.memory');
-        const extendedMemory = _.get(c, 'viewState.customInstance.extendedMemory');
-        const { zone, regional, region } = c;
-        const { locationToInstanceTypesMap } = c.backingData.credentialsKeyedByAccount[c.credentials];
-        const location = regional ? region : zone;
-
-        if (!location) {
-          return result;
-        }
-
-        if (zone || regional) {
-          _.set(
-            c,
-            'backingData.customInstanceTypes.vCpuList',
-            gceCustomInstanceBuilderService.generateValidVCpuListForLocation(location, locationToInstanceTypesMap),
-          );
-        }
-
-        // initializes vCpuCount so that memory selector will be populated.
-        if (
-          !vCpuCount ||
-          !gceCustomInstanceBuilderService.vCpuCountForLocationIsValid(
-            instanceFamily,
-            vCpuCount,
-            location,
-            locationToInstanceTypesMap,
-          )
-        ) {
-          vCpuCount = _.get(c, 'backingData.customInstanceTypes.vCpuList[0]');
-          _.set(c, 'viewState.customInstance.vCpuCount', vCpuCount);
-        }
-
+      if (zone || regional) {
         _.set(
           c,
-          'backingData.customInstanceTypes.memoryList',
-          gceCustomInstanceBuilderService.generateValidMemoryListForVCpuCount(instanceFamily, vCpuCount),
+          'backingData.customInstanceTypes.vCpuList',
+          gceCustomInstanceBuilderService.generateValidVCpuListForLocation(location, locationToInstanceTypesMap),
         );
+      }
 
-        if (
-          _.every([
-            memory,
-            vCpuCount,
-            !gceCustomInstanceBuilderService.memoryIsValid(instanceFamily, memory, vCpuCount, extendedMemory),
-          ])
-        ) {
-          _.set(c, 'viewState.customInstance.memory', undefined);
-          result.dirty.instanceType = c.instanceType;
-          c.instanceType = null;
-        }
-
-        _.set(
-          c,
-          'backingData.customInstanceTypes.instanceFamilyList',
-          gceCustomInstanceBuilderService.generateValidInstanceFamilyList(),
-        );
+      // initializes vCpuCount so that memory selector will be populated.
+      if (
+        !vCpuCount ||
+        !gceCustomInstanceBuilderService.vCpuCountForLocationIsValid(
+          instanceFamily,
+          vCpuCount,
+          location,
+          locationToInstanceTypesMap,
+        )
+      ) {
+        vCpuCount = _.get(c, 'backingData.customInstanceTypes.vCpuList[0]');
+        _.set(c, 'viewState.customInstance.vCpuCount', vCpuCount);
+      }
 
-        return result;
+      _.set(
+        c,
+        'backingData.customInstanceTypes.memoryList',
+        gceCustomInstanceBuilderService.generateValidMemoryListForVCpuCount(instanceFamily, vCpuCount),
+      );
+
+      if (
+        _.every([
+          memory,
+          vCpuCount,
+          !gceCustomInstanceBuilderService.memoryIsValid(instanceFamily, memory, vCpuCount, extendedMemory),
+        ])
+      ) {
+        _.set(c, 'viewState.customInstance.memory', undefined);
+        result.dirty.instanceType = c.instanceType;
+        c.instanceType = null;
       }
 
-      function configureAccelerators(command) {
-        const result = { dirty: {} };
-        const acceleratorTypes = GceAcceleratorService.getAvailableAccelerators(command);
-        _.set(command, ['viewState', 'acceleratorTypes'], acceleratorTypes);
-        result.dirty.acceleratorTypes = true;
-        const chosenAccelerators = _.get(command, 'acceleratorConfigs', []);
-        if (chosenAccelerators.length > 0) {
-          command.acceleratorConfigs = chosenAccelerators.filter(
-            (chosen) => !!acceleratorTypes.find((a) => a.name === chosen.acceleratorType),
-          );
-          if (command.acceleratorConfigs.length === 0) {
-            delete command.acceleratorConfigs;
-          }
+      _.set(
+        c,
+        'backingData.customInstanceTypes.instanceFamilyList',
+        gceCustomInstanceBuilderService.generateValidInstanceFamilyList(),
+      );
+
+      return result;
+    }
+
+    function configureAccelerators(command) {
+      const result = { dirty: {} };
+      const acceleratorTypes = GceAcceleratorService.getAvailableAccelerators(command);
+      _.set(command, ['viewState', 'acceleratorTypes'], acceleratorTypes);
+      result.dirty.acceleratorTypes = true;
+      const chosenAccelerators = _.get(command, 'acceleratorConfigs', []);
+      if (chosenAccelerators.length > 0) {
+        command.acceleratorConfigs = chosenAccelerators.filter(
+          (chosen) => !!acceleratorTypes.find((a) => a.name === chosen.acceleratorType),
+        );
+        if (command.acceleratorConfigs.length === 0) {
+          delete command.acceleratorConfigs;
         }
-        return result;
       }
+      return result;
+    }
+
+    // n1-standard-8 should come before n1-standard-16, so we must sort by the individual segments of the names.
+    function sortInstanceTypes(instanceTypes) {
+      const tokenizedInstanceTypes = _.map(instanceTypes, (instanceType) => {
+        const tokens = instanceType.split('-');
+
+        return {
+          class: tokens[0],
+          group: tokens[1],
+          index: Number(tokens[2]) || 0,
+        };
+      });
 
-      // n1-standard-8 should come before n1-standard-16, so we must sort by the individual segments of the names.
-      function sortInstanceTypes(instanceTypes) {
-        const tokenizedInstanceTypes = _.map(instanceTypes, (instanceType) => {
-          const tokens = instanceType.split('-');
-
-          return {
-            class: tokens[0],
-            group: tokens[1],
-            index: Number(tokens[2]) || 0,
-          };
-        });
-
-        const sortedTokenizedInstanceTypes = _.sortBy(tokenizedInstanceTypes, ['class', 'group', 'index']);
+      const sortedTokenizedInstanceTypes = _.sortBy(tokenizedInstanceTypes, ['class', 'group', 'index']);
 
-        return _.map(sortedTokenizedInstanceTypes, (sortedTokenizedInstanceType) => {
-          return (
-            sortedTokenizedInstanceType.class +
-            '-' +
-            sortedTokenizedInstanceType.group +
-            (sortedTokenizedInstanceType.index ? '-' + sortedTokenizedInstanceType.index : '')
-          );
-        });
-      }
-
-      function configureImages(command) {
-        command.image = command.viewState.imageId;
-        const result = { dirty: {} };
-        if (command.credentials !== command.viewState.lastImageAccount) {
-          command.viewState.lastImageAccount = command.credentials;
-          if (!_.chain(command.backingData.allImages).find({ imageName: command.image }).value()) {
-            command.image = null;
-            result.dirty.imageName = true;
-          }
+      return _.map(sortedTokenizedInstanceTypes, (sortedTokenizedInstanceType) => {
+        return (
+          sortedTokenizedInstanceType.class +
+          '-' +
+          sortedTokenizedInstanceType.group +
+          (sortedTokenizedInstanceType.index ? '-' + sortedTokenizedInstanceType.index : '')
+        );
+      });
+    }
+
+    function configureImages(command) {
+      command.image = command.viewState.imageId;
+      const result = { dirty: {} };
+      if (command.credentials !== command.viewState.lastImageAccount) {
+        command.viewState.lastImageAccount = command.credentials;
+        if (!_.chain(command.backingData.allImages).find({ imageName: command.image }).value()) {
+          command.image = null;
+          result.dirty.imageName = true;
         }
-        return result;
       }
+      return result;
+    }
 
-      function configureZones(command) {
-        const result = { dirty: {} };
-        const filteredData = command.backingData.filtered;
-        if (command.region === null) {
-          return result;
-        }
-        const regions = command.backingData.credentialsKeyedByAccount[command.credentials].regions;
-        if (_.isArray(regions)) {
-          filteredData.zones = _.find(regions, { name: command.region }).zones;
-          filteredData.truncatedZones = _.takeRight(filteredData.zones.sort(), 3);
-        } else {
-          // TODO(duftler): Remove this once we finish deprecating the old style regions/zones in clouddriver GCE credentials.
-          filteredData.zones = regions[command.region];
-        }
-        if (!_.chain(filteredData.zones).includes(command.zone).value()) {
-          delete command.zone;
-          if (!command.regional) {
-            result.dirty.zone = true;
-          }
-        }
+    function configureZones(command) {
+      const result = { dirty: {} };
+      const filteredData = command.backingData.filtered;
+      if (command.region === null) {
         return result;
       }
-
-      function getHealthChecks(command) {
-        const matchingHealthChecks = _.filter(command.backingData.healthChecks, { account: command.credentials });
-        return getHealthCheckOptions(matchingHealthChecks);
+      const regions = command.backingData.credentialsKeyedByAccount[command.credentials].regions;
+      if (_.isArray(regions)) {
+        filteredData.zones = _.find(regions, { name: command.region }).zones;
+        filteredData.truncatedZones = _.takeRight(filteredData.zones.sort(), 3);
+      } else {
+        // TODO(duftler): Remove this once we finish deprecating the old style regions/zones in clouddriver GCE credentials.
+        filteredData.zones = regions[command.region];
       }
-
-      function configureHealthChecks(command) {
-        const result = { dirty: {} };
-        const filteredData = command.backingData.filtered;
-
-        if (command.credentials === null) {
-          return result;
+      if (!_.chain(filteredData.zones).includes(command.zone).value()) {
+        delete command.zone;
+        if (!command.regional) {
+          result.dirty.zone = true;
         }
+      }
+      return result;
+    }
 
-        filteredData.healthChecks = getHealthChecks(command);
+    function getHealthChecks(command) {
+      const matchingHealthChecks = _.filter(command.backingData.healthChecks, { account: command.credentials });
+      return getHealthCheckOptions(matchingHealthChecks);
+    }
 
-        if (
-          _.has(command, 'autoHealingPolicy.healthCheck') &&
-          !_.chain(filteredData.healthChecks).map('selfLink').includes(command.autoHealingPolicy.healthCheckUrl).value()
-        ) {
-          delete command.autoHealingPolicy.healthCheck;
-          result.dirty.autoHealingPolicy = true;
-        } else {
-          result.dirty.autoHealingPolicy = null;
-        }
+    function configureHealthChecks(command) {
+      const result = { dirty: {} };
+      const filteredData = command.backingData.filtered;
 
+      if (command.credentials === null) {
         return result;
       }
 
-      function getLoadBalancers(command) {
-        return _.chain(command.backingData.loadBalancers)
-          .map('accounts')
-          .flattenDeep()
-          .filter({ name: command.credentials })
-          .map('regions')
-          .flattenDeep()
-          .map('loadBalancers')
-          .flattenDeep()
-          .filter(_.curry(isRelevantLoadBalancer)(command))
-          .uniq()
-          .value();
-      }
+      filteredData.healthChecks = getHealthChecks(command);
 
-      function isRelevantLoadBalancer(command, loadBalancer) {
-        return loadBalancer.region === command.region || loadBalancer.region === 'global';
+      if (
+        _.has(command, 'autoHealingPolicy.healthCheck') &&
+        !_.chain(filteredData.healthChecks).map('selfLink').includes(command.autoHealingPolicy.healthCheckUrl).value()
+      ) {
+        delete command.autoHealingPolicy.healthCheck;
+        result.dirty.autoHealingPolicy = true;
+      } else {
+        result.dirty.autoHealingPolicy = null;
       }
 
-      function configureLoadBalancerOptions(command) {
-        const results = { dirty: {} };
-        const current = command.loadBalancers;
-        const newLoadBalancerObjects = gceLoadBalancerSetTransformer.normalizeLoadBalancerSet(
-          getLoadBalancers(command),
+      return result;
+    }
+
+    function getLoadBalancers(command) {
+      return _.chain(command.backingData.loadBalancers)
+        .map('accounts')
+        .flattenDeep()
+        .filter({ name: command.credentials })
+        .map('regions')
+        .flattenDeep()
+        .map('loadBalancers')
+        .flattenDeep()
+        .filter(_.curry(isRelevantLoadBalancer)(command))
+        .uniq()
+        .value();
+    }
+
+    function isRelevantLoadBalancer(command, loadBalancer) {
+      return loadBalancer.region === command.region || loadBalancer.region === 'global';
+    }
+
+    function configureLoadBalancerOptions(command) {
+      const results = { dirty: {} };
+      const current = command.loadBalancers;
+      const newLoadBalancerObjects = gceLoadBalancerSetTransformer.normalizeLoadBalancerSet(getLoadBalancers(command));
+      command.backingData.filtered.loadBalancerIndex = _.keyBy(newLoadBalancerObjects, 'name');
+      command.backingData.filtered.loadBalancers = _.map(newLoadBalancerObjects, 'name');
+
+      if (current && command.loadBalancers) {
+        command.loadBalancers = gceHttpLoadBalancerUtils.normalizeLoadBalancerNamesForAccount(
+          command.loadBalancers,
+          command.credentials,
+          newLoadBalancerObjects,
         );
-        command.backingData.filtered.loadBalancerIndex = _.keyBy(newLoadBalancerObjects, 'name');
-        command.backingData.filtered.loadBalancers = _.map(newLoadBalancerObjects, 'name');
-
-        if (current && command.loadBalancers) {
-          command.loadBalancers = gceHttpLoadBalancerUtils.normalizeLoadBalancerNamesForAccount(
-            command.loadBalancers,
-            command.credentials,
-            newLoadBalancerObjects,
-          );
-          const matched = _.intersection(command.backingData.filtered.loadBalancers, command.loadBalancers);
-          const removed = _.xor(matched, command.loadBalancers);
-          command.loadBalancers = matched;
-          configureBackendServiceOptions(command);
-
-          if (removed.length) {
-            results.dirty.loadBalancers = removed;
-          }
+        const matched = _.intersection(command.backingData.filtered.loadBalancers, command.loadBalancers);
+        const removed = _.xor(matched, command.loadBalancers);
+        command.loadBalancers = matched;
+        configureBackendServiceOptions(command);
+
+        if (removed.length) {
+          results.dirty.loadBalancers = removed;
         }
-        return results;
       }
+      return results;
+    }
 
-      function configureBackendServiceOptions(command) {
-        /*
+    function configureBackendServiceOptions(command) {
+      /*
         a server group has a list of backend services, but there's no mapping from l7 -> backend service
         for the server group. this will not populate the wizard perfectly,
         but it is the best we can do with the given data.
       */
 
-        const backendsFromMetadata = command.backendServiceMetadata;
-        const lbIndex = command.backingData.filtered.loadBalancerIndex;
-
-        const backendServices = command.loadBalancers.reduce((backendServices, lbName) => {
-          if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(lbIndex[lbName])) {
-            backendServices[lbName] = _.intersection(lbIndex[lbName].backendServices, backendsFromMetadata);
-          }
-          return backendServices;
-        }, {});
+      const backendsFromMetadata = command.backendServiceMetadata;
+      const lbIndex = command.backingData.filtered.loadBalancerIndex;
 
-        if (Object.keys(backendServices).length > 0) {
-          command.backendServices = backendServices;
+      const backendServices = command.loadBalancers.reduce((backendServices, lbName) => {
+        if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(lbIndex[lbName])) {
+          backendServices[lbName] = _.intersection(lbIndex[lbName].backendServices, backendsFromMetadata);
         }
-      }
+        return backendServices;
+      }, {});
 
-      function refreshLoadBalancers(command, skipCommandReconfiguration) {
-        return loadBalancerReader.listLoadBalancers('gce').then(function (loadBalancers) {
-          command.backingData.loadBalancers = loadBalancers;
-          if (!skipCommandReconfiguration) {
-            configureLoadBalancerOptions(command);
-          }
-        });
-      }
-
-      function refreshHealthChecks(command, skipCommandReconfiguration) {
-        return cacheInitializer
-          .refreshCache('healthChecks')
-          .then(function () {
-            return gceHealthCheckReader.listHealthChecks();
-          })
-          .then(function (healthChecks) {
-            command.backingData.healthChecks = healthChecks;
-            if (!skipCommandReconfiguration) {
-              configureHealthChecks(command);
-            }
-          });
+      if (Object.keys(backendServices).length > 0) {
+        command.backendServices = backendServices;
       }
+    }
 
-      function configureSubnets(command) {
-        const result = { dirty: {} };
-        const filteredData = command.backingData.filtered;
-        if (command.region === null) {
-          return result;
+    function refreshLoadBalancers(command, skipCommandReconfiguration) {
+      return loadBalancerReader.listLoadBalancers('gce').then(function (loadBalancers) {
+        command.backingData.loadBalancers = loadBalancers;
+        if (!skipCommandReconfiguration) {
+          configureLoadBalancerOptions(command);
         }
-        filteredData.subnets = _.chain(command.backingData.subnets)
-          .filter({ account: command.credentials, network: command.network, region: command.region })
-          .map('id')
-          .value();
-
-        if (!_.chain(filteredData.subnets).includes(command.subnet).value()) {
-          command.subnet = '';
-          result.dirty.subnet = true;
+      });
+    }
+
+    function refreshHealthChecks(command, skipCommandReconfiguration) {
+      InfrastructureCaches.clearCache('healthChecks');
+      return gceHealthCheckReader.listHealthChecks().then(function (healthChecks) {
+        command.backingData.healthChecks = healthChecks;
+        if (!skipCommandReconfiguration) {
+          configureHealthChecks(command);
         }
+      });
+    }
+
+    function configureSubnets(command) {
+      const result = { dirty: {} };
+      const filteredData = command.backingData.filtered;
+      if (command.region === null) {
         return result;
       }
-
-      function getSecurityGroups(command) {
-        let newSecurityGroups = command.backingData.securityGroups[command.credentials] || { gce: {} };
-        newSecurityGroups = _.filter(newSecurityGroups.gce.global, function (securityGroup) {
-          return securityGroup.network === command.network;
-        });
-        return _.chain(newSecurityGroups).sortBy('name').value();
+      filteredData.subnets = _.chain(command.backingData.subnets)
+        .filter({ account: command.credentials, network: command.network, region: command.region })
+        .map('id')
+        .value();
+
+      if (!_.chain(filteredData.subnets).includes(command.subnet).value()) {
+        command.subnet = '';
+        result.dirty.subnet = true;
       }
-
-      function getXpnHostProjectIfAny(network) {
-        if (network && network.includes('/')) {
-          return network.split('/')[0] + '/';
-        } else {
-          return '';
-        }
+      return result;
+    }
+
+    function getSecurityGroups(command) {
+      let newSecurityGroups = command.backingData.securityGroups[command.credentials] || { gce: {} };
+      newSecurityGroups = _.filter(newSecurityGroups.gce.global, function (securityGroup) {
+        return securityGroup.network === command.network;
+      });
+      return _.chain(newSecurityGroups).sortBy('name').value();
+    }
+
+    function getXpnHostProjectIfAny(network) {
+      if (network && network.includes('/')) {
+        return network.split('/')[0] + '/';
+      } else {
+        return '';
       }
-
-      function configureSecurityGroupOptions(command) {
-        const results = { dirty: {} };
-        const currentOptions = command.backingData.filtered.securityGroups;
-        const newSecurityGroups = getSecurityGroups(command);
-        if (currentOptions && command.securityGroups) {
-          // not initializing - we are actually changing groups
-          const currentGroupNames = command.securityGroups.map(function (groupId) {
-            const match = _.chain(currentOptions).find({ id: groupId }).value();
-            return match ? match.id : groupId;
+    }
+
+    function configureSecurityGroupOptions(command) {
+      const results = { dirty: {} };
+      const currentOptions = command.backingData.filtered.securityGroups;
+      const newSecurityGroups = getSecurityGroups(command);
+      if (currentOptions && command.securityGroups) {
+        // not initializing - we are actually changing groups
+        const currentGroupNames = command.securityGroups.map(function (groupId) {
+          const match = _.chain(currentOptions).find({ id: groupId }).value();
+          return match ? match.id : groupId;
+        });
+        const matchedGroups = command.securityGroups
+          .map(function (groupId) {
+            const securityGroup = _.chain(currentOptions).find({ id: groupId }).value();
+            return securityGroup ? securityGroup.id : null;
+          })
+          .map(function (groupName) {
+            return _.chain(newSecurityGroups).find({ id: groupName }).value();
+          })
+          .filter(function (group) {
+            return group;
           });
-          const matchedGroups = command.securityGroups
-            .map(function (groupId) {
-              const securityGroup = _.chain(currentOptions).find({ id: groupId }).value();
-              return securityGroup ? securityGroup.id : null;
-            })
-            .map(function (groupName) {
-              return _.chain(newSecurityGroups).find({ id: groupName }).value();
-            })
-            .filter(function (group) {
-              return group;
-            });
-          command.securityGroups = _.map(matchedGroups, 'id');
-          const removed = _.xor(currentGroupNames, command.securityGroups);
-          if (removed.length) {
-            results.dirty.securityGroups = removed;
-          }
+        command.securityGroups = _.map(matchedGroups, 'id');
+        const removed = _.xor(currentGroupNames, command.securityGroups);
+        if (removed.length) {
+          results.dirty.securityGroups = removed;
         }
-
-        // Only include explicit firewall options in the pulldown list.
-        command.backingData.filtered.securityGroups = _.filter(newSecurityGroups, function (securityGroup) {
-          return !_.isEmpty(securityGroup.targetTags);
-        });
-
-        // Identify implicit firewalls so they can be optionally listed in a read-only state.
-        command.implicitSecurityGroups = _.filter(newSecurityGroups, function (securityGroup) {
-          return _.isEmpty(securityGroup.targetTags);
-        });
-
-        // Only include explicitly-selected firewalls in the body of the command.
-        const xpnHostProject = getXpnHostProjectIfAny(command.network);
-        const decoratedSecurityGroups = _.map(command.securityGroups, (sg) =>
-          !sg.startsWith(xpnHostProject) ? xpnHostProject + sg : sg,
-        );
-        command.securityGroups = _.difference(decoratedSecurityGroups, _.map(command.implicitSecurityGroups, 'id'));
-
-        return results;
       }
 
-      function refreshSecurityGroups(command, skipCommandReconfiguration) {
-        return cacheInitializer.refreshCache('securityGroups').then(function () {
-          return securityGroupReader.getAllSecurityGroups().then(function (securityGroups) {
-            command.backingData.securityGroups = securityGroups;
-            if (!skipCommandReconfiguration) {
-              configureSecurityGroupOptions(command);
-            }
-          });
-        });
-      }
+      // Only include explicit firewall options in the pulldown list.
+      command.backingData.filtered.securityGroups = _.filter(newSecurityGroups, function (securityGroup) {
+        return !_.isEmpty(securityGroup.targetTags);
+      });
+
+      // Identify implicit firewalls so they can be optionally listed in a read-only state.
+      command.implicitSecurityGroups = _.filter(newSecurityGroups, function (securityGroup) {
+        return _.isEmpty(securityGroup.targetTags);
+      });
+
+      // Only include explicitly-selected firewalls in the body of the command.
+      const xpnHostProject = getXpnHostProjectIfAny(command.network);
+      const decoratedSecurityGroups = _.map(command.securityGroups, (sg) =>
+        !sg.startsWith(xpnHostProject) ? xpnHostProject + sg : sg,
+      );
+      command.securityGroups = _.difference(decoratedSecurityGroups, _.map(command.implicitSecurityGroups, 'id'));
+
+      return results;
+    }
+
+    function refreshSecurityGroups(command, skipCommandReconfiguration) {
+      InfrastructureCaches.clearCache('securityGroups');
+      return securityGroupReader.getAllSecurityGroups().then(function (securityGroups) {
+        command.backingData.securityGroups = securityGroups;
+        if (!skipCommandReconfiguration) {
+          configureSecurityGroupOptions(command);
+        }
+      });
+    }
+
+    function getNetworkNames(command) {
+      return _.map(_.filter(command.backingData.networks, { account: command.credentials }), 'id');
+    }
+
+    function refreshNetworks(command) {
+      NetworkReader.listNetworksByProvider('gce').then(function (gceNetworks) {
+        command.backingData.networks = gceNetworks;
+      });
+    }
+
+    function refreshInstanceTypes(command) {
+      InfrastructureCaches.clearCache('instanceTypes');
+      return gceInstanceTypeService.getAllTypesByRegion().then(function (instanceTypes) {
+        command.backingData.instanceTypes = instanceTypes;
+        configureInstanceTypes(command);
+      });
+    }
+
+    function attachEventHandlers(cmd) {
+      cmd.regionalChanged = function regionalChanged(command) {
+        const result = { dirty: {} };
+        const filteredData = command.backingData.filtered;
+        const defaults = GCEProviderSettings.defaults;
+        if (command.regional) {
+          command.zone = null;
+          configureDistributionPolicyTargetShape(command);
+        } else if (!command.zone) {
+          if (command.region === defaults.region) {
+            command.zone = defaults.zone;
+          } else {
+            command.zone = filteredData.zones[0];
+          }
 
-      function getNetworkNames(command) {
-        return _.map(_.filter(command.backingData.networks, { account: command.credentials }), 'id');
-      }
+          Object.assign(result.dirty, configureZones(command).dirty);
+        }
 
-      function refreshNetworks(command) {
-        NetworkReader.listNetworksByProvider('gce').then(function (gceNetworks) {
-          command.backingData.networks = gceNetworks;
-        });
-      }
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(command.viewState.dirty, result.dirty);
+        return result;
+      };
 
-      function refreshInstanceTypes(command) {
-        return cacheInitializer.refreshCache('instanceTypes').then(function () {
-          return gceInstanceTypeService.getAllTypesByRegion().then(function (instanceTypes) {
-            command.backingData.instanceTypes = instanceTypes;
-            configureInstanceTypes(command);
-          });
-        });
-      }
+      cmd.regionChanged = function regionChanged(command) {
+        const result = { dirty: {} };
+        const filteredData = command.backingData.filtered;
+        Object.assign(result.dirty, configureSubnets(command).dirty);
+        if (command.region) {
+          Object.assign(result.dirty, configureInstanceTypes(command).dirty);
+          Object.assign(result.dirty, configureZones(command).dirty);
+          Object.assign(result.dirty, configureCpuPlatforms(command).dirty);
+          // TODO: Internal Load Balancers also need to be filtered by network.
+          Object.assign(result.dirty, configureLoadBalancerOptions(command).dirty);
+          Object.assign(result.dirty, configureImages(command).dirty);
+        } else {
+          filteredData.zones = null;
+        }
 
-      function attachEventHandlers(cmd) {
-        cmd.regionalChanged = function regionalChanged(command) {
-          const result = { dirty: {} };
-          const filteredData = command.backingData.filtered;
-          const defaults = GCEProviderSettings.defaults;
-          if (command.regional) {
-            command.zone = null;
-            configureDistributionPolicyTargetShape(command);
-          } else if (!command.zone) {
-            if (command.region === defaults.region) {
-              command.zone = defaults.zone;
-            } else {
-              command.zone = filteredData.zones[0];
-            }
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(command.viewState.dirty, result.dirty);
+        return result;
+      };
 
-            angular.extend(result.dirty, configureZones(command).dirty);
+      cmd.credentialsChanged = function credentialsChanged(command) {
+        const result = { dirty: {} };
+        const backingData = command.backingData;
+        if (command.credentials) {
+          const regions = backingData.credentialsKeyedByAccount[command.credentials].regions;
+          if (_.isArray(regions)) {
+            backingData.filtered.regions = _.map(regions, 'name');
+          } else {
+            // TODO(duftler): Remove this once we finish deprecating the old style regions/zones in clouddriver GCE credentials.
+            backingData.filtered.regions = _.keys(regions);
           }
-
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(command.viewState.dirty, result.dirty);
-          return result;
-        };
-
-        cmd.regionChanged = function regionChanged(command) {
-          const result = { dirty: {} };
-          const filteredData = command.backingData.filtered;
-          angular.extend(result.dirty, configureSubnets(command).dirty);
-          if (command.region) {
-            angular.extend(result.dirty, configureInstanceTypes(command).dirty);
-            angular.extend(result.dirty, configureZones(command).dirty);
-            angular.extend(result.dirty, configureCpuPlatforms(command).dirty);
-            // TODO: Internal Load Balancers also need to be filtered by network.
-            angular.extend(result.dirty, configureLoadBalancerOptions(command).dirty);
-            angular.extend(result.dirty, configureImages(command).dirty);
+          if (!backingData.filtered.regions.includes(command.region)) {
+            command.region = null;
+            result.dirty.region = true;
           } else {
-            filteredData.zones = null;
+            Object.assign(result.dirty, command.regionChanged(command).dirty);
           }
 
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(command.viewState.dirty, result.dirty);
-          return result;
-        };
-
-        cmd.credentialsChanged = function credentialsChanged(command) {
-          const result = { dirty: {} };
-          const backingData = command.backingData;
-          if (command.credentials) {
-            const regions = backingData.credentialsKeyedByAccount[command.credentials].regions;
-            if (_.isArray(regions)) {
-              backingData.filtered.regions = _.map(regions, 'name');
-            } else {
-              // TODO(duftler): Remove this once we finish deprecating the old style regions/zones in clouddriver GCE credentials.
-              backingData.filtered.regions = _.keys(regions);
-            }
-            if (!backingData.filtered.regions.includes(command.region)) {
-              command.region = null;
-              result.dirty.region = true;
-            } else {
-              angular.extend(result.dirty, command.regionChanged(command).dirty);
-            }
-
-            backingData.filtered.networks = getNetworkNames(command);
-            if (!backingData.filtered.networks.includes(command.network)) {
-              command.network = null;
-              result.dirty.network = true;
-            } else {
-              angular.extend(result.dirty, command.networkChanged(command).dirty);
-            }
-
-            angular.extend(result.dirty, configureHealthChecks(command).dirty);
-            angular.extend(result.dirty, configureInstanceTypes(command).dirty);
-
-            configureDistributionPolicyTargetShape(command);
+          backingData.filtered.networks = getNetworkNames(command);
+          if (!backingData.filtered.networks.includes(command.network)) {
+            command.network = null;
+            result.dirty.network = true;
           } else {
-            command.region = null;
+            Object.assign(result.dirty, command.networkChanged(command).dirty);
           }
 
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(command.viewState.dirty, result.dirty);
+          Object.assign(result.dirty, configureHealthChecks(command).dirty);
+          Object.assign(result.dirty, configureInstanceTypes(command).dirty);
 
-          return result;
-        };
+          configureDistributionPolicyTargetShape(command);
+        } else {
+          command.region = null;
+        }
+
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(command.viewState.dirty, result.dirty);
 
-        cmd.networkChanged = function networkChanged(command) {
-          const result = { dirty: {} };
+        return result;
+      };
 
-          command.viewState.autoCreateSubnets = _.chain(command.backingData.networks)
-            .filter({ account: command.credentials, id: command.network })
-            .map('autoCreateSubnets')
-            .head()
-            .value();
+      cmd.networkChanged = function networkChanged(command) {
+        const result = { dirty: {} };
 
-          command.viewState.subnets = _.chain(command.backingData.networks)
-            .filter({ account: command.credentials, id: command.network })
-            .map('subnets')
-            .head()
-            .value();
+        command.viewState.autoCreateSubnets = _.chain(command.backingData.networks)
+          .filter({ account: command.credentials, id: command.network })
+          .map('autoCreateSubnets')
+          .head()
+          .value();
 
-          angular.extend(result.dirty, configureSubnets(command).dirty);
-          angular.extend(result.dirty, configureSecurityGroupOptions(command).dirty);
+        command.viewState.subnets = _.chain(command.backingData.networks)
+          .filter({ account: command.credentials, id: command.network })
+          .map('subnets')
+          .head()
+          .value();
 
-          // TODO: Internal Load Balancers also need to be filtered by network.
+        Object.assign(result.dirty, configureSubnets(command).dirty);
+        Object.assign(result.dirty, configureSecurityGroupOptions(command).dirty);
 
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(command.viewState.dirty, result.dirty);
+        // TODO: Internal Load Balancers also need to be filtered by network.
 
-          return result;
-        };
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(command.viewState.dirty, result.dirty);
 
-        cmd.zoneChanged = function zoneChanged(command) {
-          const result = { dirty: {} };
-          if (command.zone === undefined && !command.regional) {
-            result.dirty.zone = true;
-          }
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(command.viewState.dirty, result.dirty);
-          angular.extend(command.viewState.dirty, configureInstanceTypes(command).dirty);
-          angular.extend(command.viewState.dirty, configureCpuPlatforms(command).dirty);
-          angular.extend(command.viewState.dirty, configureAccelerators(command).dirty);
-          return result;
-        };
+        return result;
+      };
 
-        cmd.selectZonesChanged = function selectZonesChanged(command) {
-          const result = { dirty: {} };
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(command.viewState.dirty, result.dirty);
-          angular.extend(command.viewState.dirty, configureAccelerators(command).dirty);
-          return result;
-        };
+      cmd.zoneChanged = function zoneChanged(command) {
+        const result = { dirty: {} };
+        if (command.zone === undefined && !command.regional) {
+          result.dirty.zone = true;
+        }
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(command.viewState.dirty, result.dirty);
+        Object.assign(command.viewState.dirty, configureInstanceTypes(command).dirty);
+        Object.assign(command.viewState.dirty, configureCpuPlatforms(command).dirty);
+        Object.assign(command.viewState.dirty, configureAccelerators(command).dirty);
+        return result;
+      };
 
-        cmd.customInstanceChanged = function customInstanceChanged(command) {
-          const result = { dirty: {} };
+      cmd.selectZonesChanged = function selectZonesChanged(command) {
+        const result = { dirty: {} };
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(command.viewState.dirty, result.dirty);
+        Object.assign(command.viewState.dirty, configureAccelerators(command).dirty);
+        return result;
+      };
 
-          command.viewState.dirty = command.viewState.dirty || {};
-          angular.extend(result, command.viewState.dirty, configureCustomInstanceTypes(command).dirty);
+      cmd.customInstanceChanged = function customInstanceChanged(command) {
+        const result = { dirty: {} };
 
-          return result;
-        };
-      }
+        command.viewState.dirty = command.viewState.dirty || {};
+        Object.assign(result, command.viewState.dirty, configureCustomInstanceTypes(command).dirty);
 
-      return {
-        configureCommand,
-        configureInstanceTypes,
-        configureImages,
-        configureZones,
-        configureSubnets,
-        configureLoadBalancerOptions,
-        refreshLoadBalancers,
-        refreshSecurityGroups,
-        refreshInstanceTypes,
-        refreshHealthChecks,
+        return result;
       };
-    },
-  ]);
+    }
+
+    return {
+      configureCommand,
+      configureInstanceTypes,
+      configureImages,
+      configureZones,
+      configureSubnets,
+      configureLoadBalancerOptions,
+      refreshLoadBalancers,
+      refreshSecurityGroups,
+      refreshInstanceTypes,
+      refreshHealthChecks,
+    };
+  }
+}