@spinnaker/google 2026.2.2 → 2026.3.0

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

@@ -1,620 +1,627 @@
 'use strict';
 
-import * as angular from 'angular';
 import _ from 'lodash';
 
-import { AccountService, ExpectedArtifactService, INSTANCE_TYPE_SERVICE } from '@spinnaker/core';
-import { GOOGLE_COMMON_XPNNAMING_GCE_SERVICE } from '../../common/xpnNaming.gce.service';
+import { AccountService, ExpectedArtifactService } from '@spinnaker/core';
+import { GceXpnNamingService } from '../../common/xpnNaming.gce.service';
 import { GCEProviderSettings } from '../../gce.settings';
 import { parseHealthCheckUrl } from '../../healthCheck/healthCheckUtils';
 
-import { GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCEBUILDER_GCE_SERVICE } from './../../instance/custom/customInstanceBuilder.gce.service';
-import { GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_HIDDENMETADATAKEYS_VALUE } from './wizard/hiddenMetadataKeys.value';
-
-export const GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE =
-  'spinnaker.gce.serverGroupCommandBuilder.service';
-export const name = GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE; // for backwards compatibility
-angular
-  .module(GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE, [
-    INSTANCE_TYPE_SERVICE,
-    GOOGLE_COMMON_XPNNAMING_GCE_SERVICE,
-    GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCEBUILDER_GCE_SERVICE,
-    GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_HIDDENMETADATAKEYS_VALUE,
-  ])
-  .factory('gceServerGroupCommandBuilder', [
-    '$q',
-    'instanceTypeService',
-    'gceCustomInstanceBuilderService',
-    'gceServerGroupHiddenMetadataKeys',
-    'gceXpnNamingService',
-    function (
-      $q,
-      instanceTypeService,
-      gceCustomInstanceBuilderService,
-      gceServerGroupHiddenMetadataKeys,
-      gceXpnNamingService,
-    ) {
-      // Two assumptions here:
-      //   1) All GCE machine types are represented in the tree of choices.
-      //   2) Each machine type appears in exactly one category.
-      function determineInstanceCategoryFromInstanceType(command) {
-        return instanceTypeService.getCategories('gce').then(function (categories) {
-          categories.forEach(function (category) {
-            category.families.forEach(function (family) {
-              family.instanceTypes.forEach(function (instanceType) {
-                if (instanceType.name === command.instanceType) {
-                  command.viewState.instanceProfile = category.type;
-                }
-              });
+import { GceCustomInstanceBuilderService } from './../../instance/custom/customInstanceBuilder.gce.service';
+import { GceInstanceTypeService } from '../../instance/gceInstanceType.service';
+import { GCE_SERVER_GROUP_HIDDEN_METADATA_KEYS } from './wizard/hiddenMetadataKeys.value';
+
+export class GceServerGroupCommandBuilder {
+  constructor(
+    promiseService,
+    instanceTypeService = new GceInstanceTypeService(promiseService),
+    gceCustomInstanceBuilderService = new GceCustomInstanceBuilderService(),
+    gceXpnNamingService = new GceXpnNamingService(),
+    gceServerGroupHiddenMetadataKeys = GCE_SERVER_GROUP_HIDDEN_METADATA_KEYS,
+  ) {
+    // Two assumptions here:
+    //   1) All GCE machine types are represented in the tree of choices.
+    //   2) Each machine type appears in exactly one category.
+    function determineInstanceCategoryFromInstanceType(command) {
+      return instanceTypeService.getCategories('gce').then(function (categories) {
+        categories.forEach(function (category) {
+          category.families.forEach(function (family) {
+            family.instanceTypes.forEach(function (instanceType) {
+              if (instanceType.name === command.instanceType) {
+                command.viewState.instanceProfile = category.type;
+              }
             });
           });
         });
+      });
+    }
+
+    function extractNetworkName(serverGroup) {
+      const projectId = gceXpnNamingService.deriveProjectId(serverGroup.launchConfig.instanceTemplate);
+      const networkUrl = _.get(serverGroup, 'launchConfig.instanceTemplate.properties.networkInterfaces[0].network');
+      return gceXpnNamingService.decorateXpnResourceIfNecessary(projectId, networkUrl);
+    }
+
+    function extractSubnetName(serverGroup) {
+      const projectId = gceXpnNamingService.deriveProjectId(serverGroup.launchConfig.instanceTemplate);
+      const subnetworkUrl = _.get(
+        serverGroup,
+        'launchConfig.instanceTemplate.properties.networkInterfaces[0].subnetwork',
+      );
+      return gceXpnNamingService.decorateXpnResourceIfNecessary(projectId, subnetworkUrl);
+    }
+
+    function determineAssociatePublicIPAddress(serverGroup) {
+      return _.has(serverGroup, 'launchConfig.instanceTemplate.properties.networkInterfaces[0].accessConfigs');
+    }
+
+    function loadBalancerMetadataValues(value) {
+      if (Array.isArray(value)) {
+        return value;
       }
-
-      function extractNetworkName(serverGroup) {
-        const projectId = gceXpnNamingService.deriveProjectId(serverGroup.launchConfig.instanceTemplate);
-        const networkUrl = _.get(serverGroup, 'launchConfig.instanceTemplate.properties.networkInterfaces[0].network');
-        return gceXpnNamingService.decorateXpnResourceIfNecessary(projectId, networkUrl);
+      if (typeof value === 'string') {
+        return value.split(',').filter(Boolean);
       }
-
-      function extractSubnetName(serverGroup) {
-        const projectId = gceXpnNamingService.deriveProjectId(serverGroup.launchConfig.instanceTemplate);
-        const subnetworkUrl = _.get(
-          serverGroup,
-          'launchConfig.instanceTemplate.properties.networkInterfaces[0].subnetwork',
-        );
-        return gceXpnNamingService.decorateXpnResourceIfNecessary(projectId, subnetworkUrl);
+      return [];
+    }
+
+    function extractLoadBalancerMetadata(metadata) {
+      return ['load-balancer-names', 'global-load-balancer-names'].reduce((loadBalancerMetadata, property) => {
+        const values = loadBalancerMetadataValues(metadata[property]);
+        if (values.length) {
+          loadBalancerMetadata[property] = values;
+        }
+        return loadBalancerMetadata;
+      }, {});
+    }
+
+    function extractLoadBalancers(asg) {
+      return ['load-balancer-names', 'global-load-balancer-names'].reduce((loadBalancers, property) => {
+        if (asg[property]) {
+          loadBalancers = loadBalancers.concat(loadBalancerMetadataValues(asg[property]));
+        }
+        return loadBalancers;
+      }, []);
+    }
+
+    function extractLoadBalancersFromMetadata(metadata) {
+      return ['load-balancer-names', 'global-load-balancer-names'].reduce((loadBalancers, property) => {
+        if (metadata[property]) {
+          loadBalancers = loadBalancers.concat(loadBalancerMetadataValues(metadata[property]));
+        }
+        return loadBalancers;
+      }, []);
+    }
+
+    function populateDisksFromExisting(disks, command) {
+      disks = disks.map((disk, index) => {
+        if (index === 0) {
+          return {
+            type: disk.initializeParams.diskType,
+            sizeGb: disk.initializeParams.diskSizeGb,
+          };
+        } else {
+          return {
+            type: disk.initializeParams.diskType,
+            sizeGb: disk.initializeParams.diskSizeGb,
+            sourceImage: _.last(_.get(disk, 'initializeParams.sourceImage', '').split('/')) || null,
+          };
+        }
+      });
+      const localSSDDisks = disks.filter((disk) => disk.type === 'local-ssd');
+      const persistentDisks = disks.filter((disk) => disk.type.startsWith('pd-') || disk.type.startsWith('hyperdisk-'));
+
+      if (persistentDisks.length) {
+        command.disks = persistentDisks.concat(localSSDDisks);
+        return instanceTypeService
+          .getInstanceTypeDetails(
+            command.selectedProvider,
+            _.includes(command.instanceType, 'custom-') ? 'buildCustom' : command.instanceType,
+          )
+          .then((instanceTypeDetails) => {
+            command.viewState.instanceTypeDetails = instanceTypeDetails;
+            calculateOverriddenStorageDescription(instanceTypeDetails, command);
+          });
+      } else {
+        command.disks = [{ type: 'pd-ssd', sizeGb: 10 }].concat(localSSDDisks);
+        return promiseService.resolve(null);
       }
-
-      function determineAssociatePublicIPAddress(serverGroup) {
-        return _.has(serverGroup, 'launchConfig.instanceTemplate.properties.networkInterfaces[0].accessConfigs');
+    }
+
+    function populateDisksFromPipeline(command) {
+      const persistentDisks = getPersistentDisks(command);
+      const localSSDDisks = getLocalSSDDisks(command);
+
+      if (persistentDisks.length) {
+        command.disks = persistentDisks.concat(localSSDDisks);
+        return instanceTypeService
+          .getInstanceTypeDetails(
+            command.selectedProvider,
+            _.includes(command.instanceType, 'custom-') ? 'buildCustom' : command.instanceType,
+          )
+          .then((instanceTypeDetails) => {
+            command.viewState.instanceTypeDetails = instanceTypeDetails;
+            calculateOverriddenStorageDescription(instanceTypeDetails, command);
+          });
+      } else {
+        command.disks = [{ type: 'pd-ssd', sizeGb: 10 }].concat(localSSDDisks);
+        return promiseService.resolve(null);
       }
+    }
 
-      function extractLoadBalancers(asg) {
-        return ['load-balancer-names', 'global-load-balancer-names'].reduce((loadBalancers, property) => {
-          if (asg[property]) {
-            loadBalancers = loadBalancers.concat(asg[property]);
-          }
-          return loadBalancers;
-        }, []);
-      }
+    function getLocalSSDDisks(command) {
+      return (command.disks || []).filter((disk) => disk.type === 'local-ssd');
+    }
 
-      function extractLoadBalancersFromMetadata(metadata) {
-        return ['load-balancer-names', 'global-load-balancer-names'].reduce((loadBalancers, property) => {
-          if (metadata[property]) {
-            loadBalancers = loadBalancers.concat(metadata[property].split(','));
-          }
-          return loadBalancers;
-        }, []);
-      }
+    function getPersistentDisks(command) {
+      return (command.disks || []).filter((disk) => disk.type.startsWith('pd-') || disk.type.startsWith('hyperdisk-'));
+    }
 
-      function populateDisksFromExisting(disks, command) {
-        disks = disks.map((disk, index) => {
-          if (index === 0) {
-            return {
-              type: disk.initializeParams.diskType,
-              sizeGb: disk.initializeParams.diskSizeGb,
-            };
-          } else {
-            return {
-              type: disk.initializeParams.diskType,
-              sizeGb: disk.initializeParams.diskSizeGb,
-              sourceImage: _.last(_.get(disk, 'initializeParams.sourceImage', '').split('/')) || null,
-            };
-          }
-        });
-        const localSSDDisks = disks.filter((disk) => disk.type === 'local-ssd');
-        const persistentDisks = disks.filter(
-          (disk) => disk.type.startsWith('pd-') || disk.type.startsWith('hyperdisk-'),
-        );
-
-        if (persistentDisks.length) {
-          command.disks = persistentDisks.concat(localSSDDisks);
-          return instanceTypeService
-            .getInstanceTypeDetails(
-              command.selectedProvider,
-              _.includes(command.instanceType, 'custom-') ? 'buildCustom' : command.instanceType,
-            )
-            .then((instanceTypeDetails) => {
-              command.viewState.instanceTypeDetails = instanceTypeDetails;
-              calculateOverriddenStorageDescription(instanceTypeDetails, command);
-            });
+    function calculatePersistentDiskOverriddenStorageDescription(command) {
+      const persistentDisks = getPersistentDisks(command);
+
+      const diskCountBySizeGb = new Map();
+      persistentDisks.forEach((disk) => {
+        if (diskCountBySizeGb.has(disk.sizeGb)) {
+          diskCountBySizeGb.set(disk.sizeGb, diskCountBySizeGb.get(disk.sizeGb) + 1);
         } else {
-          command.disks = [{ type: 'pd-ssd', sizeGb: 10 }].concat(localSSDDisks);
-          return $q.when(null);
+          diskCountBySizeGb.set(disk.sizeGb, 1);
         }
-      }
-
-      function populateDisksFromPipeline(command) {
+      });
+
+      return Array.from(diskCountBySizeGb)
+        .sort(([sizeA], [sizeB]) => sizeB - sizeA)
+        .map(([sizeGb, count]) => count + '×' + sizeGb)
+        .join(', ');
+    }
+
+    function calculateOverriddenStorageDescription(instanceTypeDetails, command) {
+      if (instanceTypeDetails.storage.localSSDSupported) {
+        if (getLocalSSDDisks(command).length !== instanceTypeDetails.storage.count) {
+          command.viewState.overriddenStorageDescription = getLocalSSDDisks(command).length + '×375';
+        }
+      } else {
         const persistentDisks = getPersistentDisks(command);
-        const localSSDDisks = getLocalSSDDisks(command);
-
-        if (persistentDisks.length) {
-          command.disks = persistentDisks.concat(localSSDDisks);
-          return instanceTypeService
-            .getInstanceTypeDetails(
-              command.selectedProvider,
-              _.includes(command.instanceType, 'custom-') ? 'buildCustom' : command.instanceType,
-            )
-            .then((instanceTypeDetails) => {
-              command.viewState.instanceTypeDetails = instanceTypeDetails;
-              calculateOverriddenStorageDescription(instanceTypeDetails, command);
-            });
-        } else {
-          command.disks = [{ type: 'pd-ssd', sizeGb: 10 }].concat(localSSDDisks);
-          return $q.when(null);
+        const overrideStorageDescription =
+          persistentDisks.some((disk) => disk.sizeGb !== instanceTypeDetails.storage.size) ||
+          persistentDisks.length !== instanceTypeDetails.storage.count;
+
+        if (overrideStorageDescription) {
+          command.viewState.overriddenStorageDescription = calculatePersistentDiskOverriddenStorageDescription(command);
         }
       }
-
-      function getLocalSSDDisks(command) {
-        return (command.disks || []).filter((disk) => disk.type === 'local-ssd');
+    }
+
+    function populateAvailabilityPolicies(scheduling, command) {
+      if (scheduling) {
+        command.preemptible = scheduling.preemptible;
+        command.automaticRestart = scheduling.automaticRestart;
+        command.onHostMaintenance = scheduling.onHostMaintenance;
+      } else {
+        command.preemptible = false;
+        command.automaticRestart = true;
+        command.onHostMaintenance = 'MIGRATE';
       }
-
-      function getPersistentDisks(command) {
-        return (command.disks || []).filter(
-          (disk) => disk.type.startsWith('pd-') || disk.type.startsWith('hyperdisk-'),
-        );
+    }
+
+    function populateAutoHealingPolicy(serverGroup, command) {
+      // Always clear first: pipeline edit copies cluster JSON onto the command before this
+      // runs, and legacy payloads may carry unsupported maxUnavailable alone or alongside
+      // a health check. Rebuild from supported fields only so Deck cannot resubmit it.
+      delete command.autoHealingPolicy;
+      const autoHealingPolicy = serverGroup.autoHealingPolicy;
+      if (!autoHealingPolicy) {
+        return;
       }
-
-      function calculatePersistentDiskOverriddenStorageDescription(command) {
-        const persistentDisks = getPersistentDisks(command);
-
-        const diskCountBySizeGb = new Map();
-        persistentDisks.forEach((disk) => {
-          if (diskCountBySizeGb.has(disk.sizeGb)) {
-            diskCountBySizeGb.set(disk.sizeGb, diskCountBySizeGb.get(disk.sizeGb) + 1);
-          } else {
-            diskCountBySizeGb.set(disk.sizeGb, 1);
-          }
-        });
-
-        return Array.from(diskCountBySizeGb)
-          .sort(([sizeA], [sizeB]) => sizeB - sizeA)
-          .map(([sizeGb, count]) => count + '×' + sizeGb)
-          .join(', ');
+      const healthCheckUrl = autoHealingPolicy.healthCheckUrl
+        ? autoHealingPolicy.healthCheckUrl
+        : autoHealingPolicy.healthCheck;
+      if (!healthCheckUrl) {
+        return;
       }
-
-      function calculateOverriddenStorageDescription(instanceTypeDetails, command) {
-        if (instanceTypeDetails.storage.localSSDSupported) {
-          if (getLocalSSDDisks(command).length !== instanceTypeDetails.storage.count) {
-            command.viewState.overriddenStorageDescription = getLocalSSDDisks(command).length + '×375';
+      const { healthCheckName, healthCheckKind } = parseHealthCheckUrl(healthCheckUrl);
+      command.autoHealingPolicy = {
+        healthCheck: healthCheckName,
+        healthCheckKind,
+        healthCheckUrl: healthCheckUrl,
+        initialDelaySec: autoHealingPolicy.initialDelaySec,
+      };
+    }
+
+    // Dual-key fallback: try v1 key (shieldedInstanceConfig) first, then legacy beta key
+    // (shieldedVmConfig) for backward compat with server groups created before the v1 migration.
+    // Ref: https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates
+    function populateShieldedVmConfig(source, command) {
+      const shieldedInstanceConfig = _.get(source, 'launchConfig.instanceTemplate.properties.shieldedInstanceConfig');
+      const shieldedVmConfig = _.get(source, 'launchConfig.instanceTemplate.properties.shieldedVmConfig');
+      ['enableSecureBoot', 'enableVtpm', 'enableIntegrityMonitoring'].forEach((field) => {
+        command[field] = _.has(shieldedInstanceConfig, field)
+          ? shieldedInstanceConfig[field]
+          : _.has(shieldedVmConfig, field)
+          ? shieldedVmConfig[field]
+          : _.get(source, field, false);
+      });
+    }
+
+    function populateCustomMetadata(metadataItems, command) {
+      // Hide metadata items in the wizard.
+      if (metadataItems) {
+        let customUserData = '';
+        let customUserDataKeys = [];
+        if (Array.isArray(metadataItems)) {
+          const customUserDataItem = metadataItems.find((metadataItem) => metadataItem.key === 'customUserData');
+          if (customUserDataItem) {
+            customUserData = customUserDataItem.value;
+            customUserDataKeys = getCustomUserDataKeys(customUserData);
+            command.userData = customUserData;
           }
+          metadataItems.forEach(function (metadataItem) {
+            if (
+              !_.includes(customUserDataKeys, metadataItem.key) &&
+              !_.includes(gceServerGroupHiddenMetadataKeys, metadataItem.key)
+            ) {
+              command.instanceMetadata[metadataItem.key] = metadataItem.value;
+            }
+          });
         } else {
-          const persistentDisks = getPersistentDisks(command);
-          const overrideStorageDescription =
-            persistentDisks.some((disk) => disk.sizeGb !== instanceTypeDetails.storage.size) ||
-            persistentDisks.length !== instanceTypeDetails.storage.count;
-
-          if (overrideStorageDescription) {
-            command.viewState.overriddenStorageDescription = calculatePersistentDiskOverriddenStorageDescription(
-              command,
-            );
+          if (metadataItems.customUserData) {
+            customUserData = metadataItems.customUserData;
+            customUserDataKeys = getCustomUserDataKeys(customUserData);
+            command.userData = customUserData;
+            metadataItems = _.omit(metadataItems, customUserDataKeys);
           }
+          Object.assign(command.instanceMetadata, _.omit(metadataItems, gceServerGroupHiddenMetadataKeys));
         }
       }
 
-      function populateAvailabilityPolicies(scheduling, command) {
-        if (scheduling) {
-          command.preemptible = scheduling.preemptible;
-          command.automaticRestart = scheduling.automaticRestart;
-          command.onHostMaintenance = scheduling.onHostMaintenance;
-        } else {
-          command.preemptible = false;
-          command.automaticRestart = true;
-          command.onHostMaintenance = 'MIGRATE';
-        }
+      if (command.labels['spinnaker-moniker-sequence']) {
+        delete command.labels['spinnaker-moniker-sequence'];
       }
-
-      function populateAutoHealingPolicy(serverGroup, command) {
-        const autoHealingPolicy = serverGroup.autoHealingPolicy;
-        if (autoHealingPolicy) {
-          const healthCheckUrl = autoHealingPolicy.healthCheckUrl
-            ? autoHealingPolicy.healthCheckUrl
-            : autoHealingPolicy.healthCheck;
-
-          if (healthCheckUrl) {
-            const { healthCheckName, healthCheckKind } = parseHealthCheckUrl(healthCheckUrl);
-            command.autoHealingPolicy = {
-              healthCheck: healthCheckName,
-              healthCheckKind: healthCheckKind,
-              healthCheckUrl: healthCheckUrl,
-              initialDelaySec: autoHealingPolicy.initialDelaySec,
-            };
-          }
-
-          const maxUnavailable = autoHealingPolicy.maxUnavailable;
-          if (maxUnavailable) {
-            command.autoHealingPolicy.maxUnavailable = maxUnavailable;
-            command.viewState.maxUnavailableMetric = typeof maxUnavailable.percent === 'number' ? 'percent' : 'fixed';
-          }
-        }
+    }
+
+    function getCustomUserDataKeys(customUserData) {
+      const customUserDataKeys = [];
+      customUserData.split(/\n|,/).forEach(function (userDataItem) {
+        const customUserDataKey = userDataItem.split('=')[0];
+        customUserDataKeys.push(customUserDataKey);
+      });
+      return customUserDataKeys;
+    }
+
+    function populateTags(instanceTemplateTags, command) {
+      if (instanceTemplateTags && instanceTemplateTags.items) {
+        _.map(instanceTemplateTags.items, function (tag) {
+          command.tags.push({ value: tag });
+        });
       }
+    }
 
-      function populateShieldedVmConfig(serverGroup, command) {
-        command.enableSecureBoot = serverGroup.enableSecureBoot;
-        command.enableVtpm = serverGroup.enableVtpm;
-        command.enableIntegrityMonitoring = serverGroup.enableIntegrityMonitoring;
+    function populateResourceManagerTags(instanceTemplateResourceManagerTags, command) {
+      if (instanceTemplateResourceManagerTags) {
+        Object.assign(command.resourceManagerTags, instanceTemplateResourceManagerTags);
       }
+    }
 
-      function populateCustomMetadata(metadataItems, command) {
-        // Hide metadata items in the wizard.
-        if (metadataItems) {
-          let customUserData = '';
-          let customUserDataKeys = [];
-          if (angular.isArray(metadataItems)) {
-            const customUserDataItem = metadataItems.find((metadataItem) => metadataItem.key === 'customUserData');
-            if (customUserDataItem) {
-              customUserData = customUserDataItem.value;
-              customUserDataKeys = getCustomUserDataKeys(customUserData);
-              command.userData = customUserData;
-            }
-            metadataItems.forEach(function (metadataItem) {
-              if (
-                !_.includes(customUserDataKeys, metadataItem.key) &&
-                !_.includes(gceServerGroupHiddenMetadataKeys, metadataItem.key)
-              ) {
-                command.instanceMetadata[metadataItem.key] = metadataItem.value;
-              }
-            });
-          } else {
-            if (metadataItems.customUserData) {
-              customUserData = metadataItems.customUserData;
-              customUserDataKeys = getCustomUserDataKeys(customUserData);
-              command.userData = customUserData;
-              metadataItems = _.omit(metadataItems, customUserDataKeys);
-            }
-            angular.extend(command.instanceMetadata, _.omit(metadataItems, gceServerGroupHiddenMetadataKeys));
-          }
+    function populateLabels(instanceTemplateLabels, command) {
+      if (instanceTemplateLabels) {
+        Object.assign(command.labels, instanceTemplateLabels);
+
+        if (command.labels['spinnaker-region']) {
+          delete command.labels['spinnaker-region'];
         }
 
+        if (command.labels['spinnaker-server-group']) {
+          delete command.labels['spinnaker-server-group'];
+        }
+
+        // Need to delete the sequence, otherwise it won't increment
         if (command.labels['spinnaker-moniker-sequence']) {
           delete command.labels['spinnaker-moniker-sequence'];
         }
       }
+    }
 
-      function getCustomUserDataKeys(customUserData) {
-        const customUserDataKeys = [];
-        customUserData.split(/\n|,/).forEach(function (userDataItem) {
-          const customUserDataKey = userDataItem.split('=')[0];
-          customUserDataKeys.push(customUserDataKey);
+    function populateAuthScopes(serviceAccounts, command) {
+      if (serviceAccounts && serviceAccounts.length) {
+        command.serviceAccountEmail = serviceAccounts[0].email;
+        command.authScopes = _.map(serviceAccounts[0].scopes, (authScope) => {
+          return authScope.replace('https://www.googleapis.com/auth/', '');
         });
-        return customUserDataKeys;
-      }
-
-      function populateTags(instanceTemplateTags, command) {
-        if (instanceTemplateTags && instanceTemplateTags.items) {
-          _.map(instanceTemplateTags.items, function (tag) {
-            command.tags.push({ value: tag });
-          });
-        }
-      }
-
-      function populateResourceManagerTags(instanceTemplateResourceManagerTags, command) {
-        if (instanceTemplateResourceManagerTags) {
-          Object.assign(command.resourceManagerTags, instanceTemplateResourceManagerTags);
-        }
+      } else {
+        command.authScopes = [];
       }
+    }
+
+    function attemptToSetValidCredentials(application, defaultCredentials, command) {
+      return AccountService.listAccounts('gce').then(function (gceAccounts) {
+        const gceAccountNames = _.map(gceAccounts, 'name');
+        const firstGCEAccount = gceAccountNames[0];
+
+        const defaultCredentialsAreValid = defaultCredentials && gceAccountNames.includes(defaultCredentials);
+
+        command.credentials = defaultCredentialsAreValid ? defaultCredentials : firstGCEAccount || 'my-account-name';
+      });
+    }
+
+    function buildNewServerGroupCommand(application, defaults) {
+      defaults = defaults || {};
+
+      const defaultCredentials = defaults.account || GCEProviderSettings.defaults.account;
+      const defaultRegion = defaults.region || GCEProviderSettings.defaults.region;
+      const defaultZone = defaults.zone || GCEProviderSettings.defaults.zone;
+      const associatePublicIpAddress = _.has(application, 'attributes.providerSettings.gce.associatePublicIpAddress')
+        ? application.attributes.providerSettings.gce.associatePublicIpAddress
+        : true;
+
+      const command = {
+        application: application.name,
+        credentials: defaultCredentials,
+        region: defaultRegion,
+        zone: defaultZone,
+        regional: false, // TODO(duftler): Externalize this default alongside defaultRegion and defaultZone.
+        selectZones: false, // Explicitly select zones for regional server groups.
+        distributionPolicy: { zones: [] },
+        network: 'default',
+        associatePublicIpAddress: associatePublicIpAddress,
+        canIpForward: false,
+        strategy: '',
+        capacity: {
+          min: 0,
+          max: 0,
+          desired: 1,
+        },
+        backendServiceMetadata: [],
+        minCpuPlatform: '(Automatic)',
+        disks: [
+          { type: 'pd-ssd', sizeGb: 10 },
+          { type: 'local-ssd', sizeGb: 375 },
+        ],
+        imageSource: 'priorStage',
+        instanceMetadata: {},
+        tags: [],
+        labels: {},
+        resourceManagerTags: {},
+        enableSecureBoot: false,
+        enableVtpm: false,
+        enableIntegrityMonitoring: false,
+        preemptible: false,
+        automaticRestart: true,
+        onHostMaintenance: 'MIGRATE',
+        serviceAccountEmail: 'default',
+        authScopes: ['cloud.useraccounts.readonly', 'devstorage.read_only', 'logging.write', 'monitoring.write'],
+        enableTraffic: true,
+        cloudProvider: 'gce',
+        selectedProvider: 'gce',
+        availabilityZones: [],
+        viewState: {
+          instanceProfile: 'custom',
+          allImageSelection: null,
+          useSimpleCapacity: true,
+          usePreferredZones: true,
+          listImplicitSecurityGroups: false,
+          mode: defaults.mode || 'create',
+          disableStrategySelection: true,
+          expectedArtifacts: [],
+        },
+      };
 
-      function populatePartnerMetadata(instanceTemplatePartnerMetadata, command) {
-        if (instanceTemplatePartnerMetadata) {
-          Object.assign(command.partnerMetadata, instanceTemplatePartnerMetadata);
-        }
+      if (
+        application.attributes &&
+        application.attributes.platformHealthOnlyShowOverride &&
+        application.attributes.platformHealthOnly
+      ) {
+        command.interestingHealthProviderNames = ['Google'];
       }
 
-      function populateLabels(instanceTemplateLabels, command) {
-        if (instanceTemplateLabels) {
-          Object.assign(command.labels, instanceTemplateLabels);
-
-          if (command.labels['spinnaker-region']) {
-            delete command.labels['spinnaker-region'];
-          }
+      return attemptToSetValidCredentials(application, defaultCredentials, command).then(() => command);
+    }
+
+    // Only used to prepare view requiring template selecting
+    function buildNewServerGroupCommandForPipeline(currentStage, pipeline) {
+      const expectedArtifacts = ExpectedArtifactService.getExpectedArtifactsAvailableToStage(currentStage, pipeline);
+      return promiseService.resolve({
+        viewState: {
+          pipeline,
+          expectedArtifacts: expectedArtifacts,
+          requiresTemplateSelection: true,
+          stage: currentStage,
+        },
+      });
+    }
+
+    function buildServerGroupCommandFromExisting(application, serverGroup, mode) {
+      mode = mode || 'clone';
+      const moniker = serverGroup.moniker;
+
+      const command = {
+        application: application.name,
+        autoscalingPolicy: _.cloneDeep(serverGroup.autoscalingPolicy),
+        strategy: '',
+        stack: moniker.stack,
+        freeFormDetails: moniker.detail,
+        credentials: serverGroup.account,
+        loadBalancers: extractLoadBalancers(serverGroup.asg),
+        loadBalancerMetadata: extractLoadBalancerMetadata(serverGroup.asg),
+        loadBalancingPolicy: _.cloneDeep(serverGroup.loadBalancingPolicy),
+        backendServiceMetadata: serverGroup.asg['backend-service-names'],
+        securityGroups: serverGroup.securityGroups,
+        region: serverGroup.region,
+        capacity: {
+          min: serverGroup.asg.minSize,
+          max: serverGroup.asg.maxSize,
+          desired: serverGroup.asg.desiredCapacity,
+        },
+        regional: serverGroup.regional,
+        network: extractNetworkName(serverGroup),
+        subnet: extractSubnetName(serverGroup),
+        associatePublicIpAddress: determineAssociatePublicIPAddress(serverGroup),
+        canIpForward: serverGroup.canIpForward,
+        minCpuPlatform: serverGroup.launchConfig.minCpuPlatform || '(Automatic)',
+        instanceMetadata: {},
+        tags: [],
+        labels: {},
+        resourceManagerTags: {},
+        availabilityZones: [],
+        enableSecureBoot: false,
+        enableVtpm: false,
+        enableIntegrityMonitoring: false,
+        enableTraffic: true,
+        cloudProvider: 'gce',
+        selectedProvider: 'gce',
+        distributionPolicy: {
+          zones: serverGroup.distributionPolicy ? serverGroup.distributionPolicy.zones : [],
+          targetShape: serverGroup.distributionPolicy ? serverGroup.distributionPolicy.targetShape : null,
+        },
+        // Preserve explicit empty policies while keeping absence distinct.
+        instanceFlexibilityPolicy:
+          serverGroup.instanceFlexibilityPolicy === undefined
+            ? undefined
+            : _.cloneDeep(serverGroup.instanceFlexibilityPolicy),
+        selectZones: serverGroup.selectZones,
+        source: {
+          account: serverGroup.account,
+          region: serverGroup.region,
+          serverGroupName: serverGroup.name,
+          asgName: serverGroup.name,
+        },
+        viewState: {
+          allImageSelection: null,
+          useSimpleCapacity: !serverGroup.autoscalingPolicy,
+          usePreferredZones: false,
+          listImplicitSecurityGroups: false,
+          mode: mode,
+        },
+      };
 
-          if (command.labels['spinnaker-server-group']) {
-            delete command.labels['spinnaker-server-group'];
-          }
+      populateShieldedVmConfig(serverGroup, command);
 
-          // Need to delete the sequence, otherwise it won't increment
-          if (command.labels['spinnaker-moniker-sequence']) {
-            delete command.labels['spinnaker-moniker-sequence'];
-          }
-        }
+      if (!command.regional) {
+        command.zone = serverGroup.zones[0];
+        command.source.zone = serverGroup.zones[0];
       }
 
-      function populateAuthScopes(serviceAccounts, command) {
-        if (serviceAccounts && serviceAccounts.length) {
-          command.serviceAccountEmail = serviceAccounts[0].email;
-          command.authScopes = _.map(serviceAccounts[0].scopes, (authScope) => {
-            return authScope.replace('https://www.googleapis.com/auth/', '');
-          });
-        } else {
-          command.authScopes = [];
-        }
+      if (
+        application.attributes &&
+        application.attributes.platformHealthOnlyShowOverride &&
+        application.attributes.platformHealthOnly
+      ) {
+        command.interestingHealthProviderNames = ['Google'];
       }
 
-      function attemptToSetValidCredentials(application, defaultCredentials, command) {
-        return AccountService.listAccounts('gce').then(function (gceAccounts) {
-          const gceAccountNames = _.map(gceAccounts, 'name');
-          const firstGCEAccount = gceAccountNames[0];
-
-          const defaultCredentialsAreValid = defaultCredentials && gceAccountNames.includes(defaultCredentials);
+      populateAutoHealingPolicy(serverGroup, command);
 
-          command.credentials = defaultCredentialsAreValid ? defaultCredentials : firstGCEAccount || 'my-account-name';
+      if (serverGroup.launchConfig) {
+        const instanceType = serverGroup.launchConfig.instanceType;
+        Object.assign(command, {
+          instanceType: instanceType,
         });
-      }
 
-      function buildNewServerGroupCommand(application, defaults) {
-        defaults = defaults || {};
-
-        const defaultCredentials = defaults.account || GCEProviderSettings.defaults.account;
-        const defaultRegion = defaults.region || GCEProviderSettings.defaults.region;
-        const defaultZone = defaults.zone || GCEProviderSettings.defaults.zone;
-        const associatePublicIpAddress = _.has(application, 'attributes.providerSettings.gce.associatePublicIpAddress')
-          ? application.attributes.providerSettings.gce.associatePublicIpAddress
-          : true;
-
-        const command = {
-          application: application.name,
-          credentials: defaultCredentials,
-          region: defaultRegion,
-          zone: defaultZone,
-          regional: false, // TODO(duftler): Externalize this default alongside defaultRegion and defaultZone.
-          selectZones: false, // Explicitly select zones for regional server groups.
-          distributionPolicy: { zones: [] },
-          network: 'default',
-          associatePublicIpAddress: associatePublicIpAddress,
-          canIpForward: false,
-          strategy: '',
-          capacity: {
-            min: 0,
-            max: 0,
-            desired: 1,
-          },
-          backendServiceMetadata: [],
-          minCpuPlatform: '(Automatic)',
-          disks: [
-            { type: 'pd-ssd', sizeGb: 10 },
-            { type: 'local-ssd', sizeGb: 375 },
-          ],
-          imageSource: 'priorStage',
-          instanceMetadata: {},
-          tags: [],
-          labels: {},
-          resourceManagerTags: {},
-          partnerMetadata: {},
-          enableSecureBoot: false,
-          enableVtpm: false,
-          enableIntegrityMonitoring: false,
-          preemptible: false,
-          automaticRestart: true,
-          onHostMaintenance: 'MIGRATE',
-          serviceAccountEmail: 'default',
-          authScopes: ['cloud.useraccounts.readonly', 'devstorage.read_only', 'logging.write', 'monitoring.write'],
-          enableTraffic: true,
-          cloudProvider: 'gce',
-          selectedProvider: 'gce',
-          availabilityZones: [],
-          viewState: {
-            instanceProfile: 'custom',
-            allImageSelection: null,
-            useSimpleCapacity: true,
-            usePreferredZones: true,
-            listImplicitSecurityGroups: false,
-            mode: defaults.mode || 'create',
-            disableStrategySelection: true,
-            expectedArtifacts: [],
-          },
-        };
-
-        if (
-          application.attributes &&
-          application.attributes.platformHealthOnlyShowOverride &&
-          application.attributes.platformHealthOnly
-        ) {
-          command.interestingHealthProviderNames = ['Google'];
+        if (_.includes(instanceType, 'custom-')) {
+          command.viewState.customInstance = gceCustomInstanceBuilderService.parseInstanceTypeString(instanceType);
+          command.viewState.instanceProfile = 'buildCustom';
         }
 
-        return attemptToSetValidCredentials(application, defaultCredentials, command).then(() => command);
+        command.viewState.imageId = serverGroup.launchConfig.imageId;
+        return determineInstanceCategoryFromInstanceType(command).then(function () {
+          populateAvailabilityPolicies(serverGroup.launchConfig.instanceTemplate.properties.scheduling, command);
+          populateCustomMetadata(serverGroup.launchConfig.instanceTemplate.properties.metadata.items, command);
+          populateTags(serverGroup.launchConfig.instanceTemplate.properties.tags, command);
+          populateLabels(serverGroup.instanceTemplateLabels, command);
+          populateAuthScopes(serverGroup.launchConfig.instanceTemplate.properties.serviceAccounts, command);
+          populateResourceManagerTags(
+            serverGroup.launchConfig.instanceTemplate.properties.resourceManagerTags,
+            command,
+          );
+
+          return populateDisksFromExisting(serverGroup.launchConfig.instanceTemplate.properties.disks, command).then(
+            function () {
+              return command;
+            },
+          );
+        });
       }
 
-      // Only used to prepare view requiring template selecting
-      function buildNewServerGroupCommandForPipeline(currentStage, pipeline) {
-        const expectedArtifacts = ExpectedArtifactService.getExpectedArtifactsAvailableToStage(currentStage, pipeline);
-        return $q.when({
-          viewState: {
+      return promiseService.resolve(command);
+    }
+
+    function buildServerGroupCommandFromPipeline(application, originalCluster, currentStage, pipeline) {
+      const pipelineCluster = _.cloneDeep(originalCluster);
+      const region = Object.keys(pipelineCluster.availabilityZones)[0];
+      const zone = pipelineCluster.zone;
+      const instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType(
+        'gce',
+        pipelineCluster.instanceType,
+      );
+
+      const commandOptions = { account: pipelineCluster.account, region: region, zone: zone };
+      return promiseService
+        .all([buildNewServerGroupCommand(application, commandOptions), instanceTypeCategoryLoader])
+        .then(function ([command, instanceProfile]) {
+          const expectedArtifacts = ExpectedArtifactService.getExpectedArtifactsAvailableToStage(
+            currentStage,
+            pipeline,
+          );
+          const viewState = {
             pipeline,
-            expectedArtifacts: expectedArtifacts,
-            requiresTemplateSelection: true,
             stage: currentStage,
-          },
-        });
-      }
-
-      function buildServerGroupCommandFromExisting(application, serverGroup, mode) {
-        mode = mode || 'clone';
-        const moniker = serverGroup.moniker;
-
-        const command = {
-          application: application.name,
-          autoscalingPolicy: _.cloneDeep(serverGroup.autoscalingPolicy),
-          strategy: '',
-          stack: moniker.stack,
-          freeFormDetails: moniker.detail,
-          credentials: serverGroup.account,
-          loadBalancers: extractLoadBalancers(serverGroup.asg),
-          loadBalancingPolicy: _.cloneDeep(serverGroup.loadBalancingPolicy),
-          backendServiceMetadata: serverGroup.asg['backend-service-names'],
-          securityGroups: serverGroup.securityGroups,
-          region: serverGroup.region,
-          capacity: {
-            min: serverGroup.asg.minSize,
-            max: serverGroup.asg.maxSize,
-            desired: serverGroup.asg.desiredCapacity,
-          },
-          regional: serverGroup.regional,
-          network: extractNetworkName(serverGroup),
-          subnet: extractSubnetName(serverGroup),
-          associatePublicIpAddress: determineAssociatePublicIPAddress(serverGroup),
-          canIpForward: serverGroup.canIpForward,
-          minCpuPlatform: serverGroup.launchConfig.minCpuPlatform || '(Automatic)',
-          instanceMetadata: {},
-          tags: [],
-          labels: {},
-          resourceManagerTags: {},
-          partnerMetadata: {},
-          availabilityZones: [],
-          enableSecureBoot: serverGroup.enableSecureBoot,
-          enableVtpm: serverGroup.enableVtpm,
-          enableIntegrityMonitoring: serverGroup.enableIntegrityMonitoring,
-          enableTraffic: true,
-          cloudProvider: 'gce',
-          selectedProvider: 'gce',
-          distributionPolicy: {
-            zones: serverGroup.distributionPolicy ? serverGroup.distributionPolicy.zones : [],
-            targetShape: serverGroup.distributionPolicy ? serverGroup.distributionPolicy.targetShape : null,
-          },
-          selectZones: serverGroup.selectZones,
-          source: {
-            account: serverGroup.account,
-            region: serverGroup.region,
-            serverGroupName: serverGroup.name,
-            asgName: serverGroup.name,
-          },
-          viewState: {
-            allImageSelection: null,
-            useSimpleCapacity: !serverGroup.autoscalingPolicy,
-            usePreferredZones: false,
-            listImplicitSecurityGroups: false,
-            mode: mode,
-          },
-        };
-
-        if (!command.regional) {
-          command.zone = serverGroup.zones[0];
-          command.source.zone = serverGroup.zones[0];
-        }
-
-        if (
-          application.attributes &&
-          application.attributes.platformHealthOnlyShowOverride &&
-          application.attributes.platformHealthOnly
-        ) {
-          command.interestingHealthProviderNames = ['Google'];
-        }
-
-        populateAutoHealingPolicy(serverGroup, command);
-
-        if (serverGroup.launchConfig) {
-          const instanceType = serverGroup.launchConfig.instanceType;
-          angular.extend(command, {
-            instanceType: instanceType,
-          });
-
-          if (_.includes(instanceType, 'custom-')) {
-            command.viewState.customInstance = gceCustomInstanceBuilderService.parseInstanceTypeString(instanceType);
-            command.viewState.instanceProfile = 'buildCustom';
-          }
-
-          command.viewState.imageId = serverGroup.launchConfig.imageId;
-          return determineInstanceCategoryFromInstanceType(command).then(function () {
-            populateAvailabilityPolicies(serverGroup.launchConfig.instanceTemplate.properties.scheduling, command);
-            populateCustomMetadata(serverGroup.launchConfig.instanceTemplate.properties.metadata.items, command);
-            populateTags(serverGroup.launchConfig.instanceTemplate.properties.tags, command);
-            populateLabels(serverGroup.instanceTemplateLabels, command);
-            populateAuthScopes(serverGroup.launchConfig.instanceTemplate.properties.serviceAccounts, command);
-            populateResourceManagerTags(
-              serverGroup.launchConfig.instanceTemplate.properties.resourceManagerTags,
-              command,
-            );
-            populatePartnerMetadata(serverGroup.launchConfig.instanceTemplate.properties.partnerMetadata, command);
-
-            return populateDisksFromExisting(serverGroup.launchConfig.instanceTemplate.properties.disks, command).then(
-              function () {
-                return command;
-              },
-            );
-          });
-        }
-
-        return $q.when(command);
-      }
-
-      function buildServerGroupCommandFromPipeline(application, originalCluster, currentStage, pipeline) {
-        const pipelineCluster = _.cloneDeep(originalCluster);
-        const region = Object.keys(pipelineCluster.availabilityZones)[0];
-        const zone = pipelineCluster.zone;
-        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType(
-          'gce',
-          pipelineCluster.instanceType,
-        );
-
-        const commandOptions = { account: pipelineCluster.account, region: region, zone: zone };
-        return $q
-          .all([buildNewServerGroupCommand(application, commandOptions), instanceTypeCategoryLoader])
-          .then(function ([command, instanceProfile]) {
-            const expectedArtifacts = ExpectedArtifactService.getExpectedArtifactsAvailableToStage(
-              currentStage,
-              pipeline,
-            );
-            const viewState = {
-              pipeline,
-              stage: currentStage,
-              instanceProfile,
-              disableImageSelection: true,
-              expectedArtifacts: expectedArtifacts,
-              showImageSourceSelector: true,
-              useSimpleCapacity: !pipelineCluster.autoscalingPolicy,
-              mode: 'editPipeline',
-              submitButtonLabel: 'Done',
-              customInstance:
-                instanceProfile === 'buildCustom'
-                  ? gceCustomInstanceBuilderService.parseInstanceTypeString(pipelineCluster.instanceType)
-                  : null,
-              templatingEnabled: true,
-            };
-
-            const viewOverrides = {
-              region: region,
-              credentials: pipelineCluster.account,
-              enableTraffic: !pipelineCluster.disableTraffic,
-              viewState: viewState,
-            };
-
-            pipelineCluster.strategy = pipelineCluster.strategy || '';
-
-            const extendedCommand = angular.extend({}, command, pipelineCluster, viewOverrides);
-
-            return populateDisksFromPipeline(extendedCommand).then(function () {
-              const instanceMetadata = extendedCommand.instanceMetadata;
-              extendedCommand.loadBalancers = extractLoadBalancersFromMetadata(instanceMetadata);
-              extendedCommand.backendServiceMetadata = instanceMetadata['backend-service-names']
-                ? instanceMetadata['backend-service-names'].split(',')
-                : [];
-              extendedCommand.minCpuPlatform = pipelineCluster.minCpuPlatform || '(Automatic)';
-              extendedCommand.instanceMetadata = {};
-              populateCustomMetadata(instanceMetadata, extendedCommand);
-              populateAutoHealingPolicy(pipelineCluster, extendedCommand);
-              populateShieldedVmConfig(pipelineCluster, extendedCommand);
-
-              const instanceTemplateTags = { items: extendedCommand.tags };
-              extendedCommand.tags = [];
-              populateTags(instanceTemplateTags, extendedCommand);
-
-              const resourceManagerTags = extendedCommand.resourceManagerTags;
-              populateResourceManagerTags(resourceManagerTags, extendedCommand);
-
-              const partnerMetadata = extendedCommand.partnerMetadata;
-              populatePartnerMetadata(partnerMetadata, extendedCommand);
-
-              return extendedCommand;
-            });
+            instanceProfile,
+            disableImageSelection: true,
+            expectedArtifacts: expectedArtifacts,
+            showImageSourceSelector: true,
+            useSimpleCapacity: !pipelineCluster.autoscalingPolicy,
+            mode: 'editPipeline',
+            submitButtonLabel: 'Done',
+            customInstance:
+              instanceProfile === 'buildCustom'
+                ? gceCustomInstanceBuilderService.parseInstanceTypeString(pipelineCluster.instanceType)
+                : null,
+            templatingEnabled: true,
+          };
+
+          const viewOverrides = {
+            region: region,
+            credentials: pipelineCluster.account,
+            enableTraffic: !pipelineCluster.disableTraffic,
+            viewState: viewState,
+          };
+
+          pipelineCluster.strategy = pipelineCluster.strategy || '';
+
+          const extendedCommand = Object.assign({}, command, pipelineCluster, viewOverrides);
+          // Older saved pipeline payloads may still include partnerMetadata. Do not propagate it
+          // into deploy/clone commands that eventually create stable Compute v1 instance templates.
+          delete extendedCommand.partnerMetadata;
+
+          return populateDisksFromPipeline(extendedCommand).then(function () {
+            const instanceMetadata = extendedCommand.instanceMetadata;
+            extendedCommand.loadBalancers = extractLoadBalancersFromMetadata(instanceMetadata);
+            extendedCommand.loadBalancerMetadata = extractLoadBalancerMetadata(instanceMetadata);
+            extendedCommand.backendServiceMetadata = instanceMetadata['backend-service-names']
+              ? instanceMetadata['backend-service-names'].split(',')
+              : [];
+            extendedCommand.minCpuPlatform = pipelineCluster.minCpuPlatform || '(Automatic)';
+            extendedCommand.instanceMetadata = {};
+            populateCustomMetadata(instanceMetadata, extendedCommand);
+            populateAutoHealingPolicy(pipelineCluster, extendedCommand);
+            populateShieldedVmConfig(pipelineCluster, extendedCommand);
+
+            const instanceTemplateTags = { items: extendedCommand.tags };
+            extendedCommand.tags = [];
+            populateTags(instanceTemplateTags, extendedCommand);
+
+            const resourceManagerTags = extendedCommand.resourceManagerTags;
+            populateResourceManagerTags(resourceManagerTags, extendedCommand);
+
+            return extendedCommand;
           });
-      }
-
-      return {
-        buildNewServerGroupCommand: buildNewServerGroupCommand,
-        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
-        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
-        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
-      };
-    },
-  ]);
+        });
+    }
+
+    return {
+      buildNewServerGroupCommand: buildNewServerGroupCommand,
+      buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
+      buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
+      buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
+    };
+  }
+}