@spinnaker/azure 0.0.0-main-2

package/src/securityGroup/securityGroup.reader.js

@@ -0,0 +1,17 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const AZURE_SECURITYGROUP_SECURITYGROUP_READER = 'spinnaker.azure.securityGroup.reader';
+export const name = AZURE_SECURITYGROUP_SECURITYGROUP_READER; // for backwards compatibility
+module(AZURE_SECURITYGROUP_SECURITYGROUP_READER, []).factory('azureSecurityGroupReader', function () {
+  function resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId) {
+    //hack to get around securityGroupId not matching id in indexedSecurityGroups.
+    const temp = securityGroupId.split('/');
+    return indexedSecurityGroups[container.account][container.region][temp[temp.length - 1]];
+  }
+
+  return {
+    resolveIndexedSecurityGroup: resolveIndexedSecurityGroup,
+  };
+});

package/src/securityGroup/securityGroup.transformer.js

@@ -0,0 +1,13 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER = 'spinnaker.azure.securityGroup.transformer';
+export const name = AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER; // for backwards compatibility
+module(AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER, []).factory('azureSecurityGroupTransformer', function () {
+  function normalizeSecurityGroup() {}
+
+  return {
+    normalizeSecurityGroup: normalizeSecurityGroup,
+  };
+});

package/src/securityGroup/securityGroup.write.service.js

@@ -0,0 +1,57 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { FirewallLabels, InfrastructureCaches, TaskExecutor } from '@spinnaker/core';
+
+export const AZURE_SECURITYGROUP_SECURITYGROUP_WRITE_SERVICE = 'spinnaker.azure.securityGroup.write.service';
+export const name = AZURE_SECURITYGROUP_SECURITYGROUP_WRITE_SERVICE; // for backwards compatibility
+module(AZURE_SECURITYGROUP_SECURITYGROUP_WRITE_SERVICE, [UIROUTER_ANGULARJS]).factory(
+  'azureSecurityGroupWriter',
+  function () {
+    function upsertSecurityGroup(securityGroup, application, descriptor, params = {}) {
+      params.securityGroupName = securityGroup.name;
+
+      // We want to extend params with all attributes from securityGroup, but only if they don't already exist.
+      _.assignWith(params, securityGroup, function (value, other) {
+        return _.isUndefined(value) ? other : value;
+      });
+
+      const operation = TaskExecutor.executeTask({
+        job: [params],
+        application: application,
+        description: `${descriptor} ${FirewallLabels.get('Firewall')}: ${name}`,
+      });
+
+      InfrastructureCaches.clearCache('securityGroup');
+
+      return operation;
+    }
+
+    function deleteSecurityGroup(securityGroup, application, params = {}) {
+      params.type = 'deleteSecurityGroup';
+      params.securityGroupName = securityGroup.name;
+      params.regions = [securityGroup.region];
+      params.credentials = securityGroup.accountId;
+      //params.cloudProvider = securityGroup.providerType;
+      params.appName = application.name;
+
+      const operation = TaskExecutor.executeTask({
+        job: [params],
+        application: application,
+        description: `Delete ${FirewallLabels.get('Firewalls')}: ${securityGroup.name}`,
+      });
+
+      InfrastructureCaches.clearCache('securityGroup');
+
+      return operation;
+    }
+
+    return {
+      deleteSecurityGroup: deleteSecurityGroup,
+      upsertSecurityGroup: upsertSecurityGroup,
+    };
+  },
+);

package/src/serverGroup/configure/serverGroup.configure.azure.module.js

@@ -0,0 +1,47 @@
+import { module } from 'angular';
+
+import { AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER } from '../serverGroup.transformer';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_SERVERGROUPINSTANCEARCHETYPE_CONTROLLER } from './wizard/ServerGroupInstanceArchetype.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_SERVERGROUPINSTANCETYPE_CONTROLLER } from './wizard/ServerGroupInstanceType.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_SERVERGROUPADVANCEDSETTINGS_CONTROLLER } from './wizard/advancedSettings/ServerGroupAdvancedSettings.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_ADVANCEDSETTINGSSELECTOR_DIRECTIVE } from './wizard/advancedSettings/advancedSettingsSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_BASICSETTINGS_SERVERGROUPBASICSETTINGS_CONTROLLER } from './wizard/basicSettings/ServerGroupBasicSettings.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_CAPACITY_CAPACITYSELECTOR_DIRECTIVE } from './wizard/capacity/capacitySelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_HEALTHSETTINGS_SERVERGROUPHEALTHSETTINGS_CONTROLLER } from './wizard/healthSettings/ServerGroupHealthSettings.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_HEALTHSETTINGS_HEALTHSETTINGSSELECTOR_DIRECTIVE } from './wizard/healthSettings/healthSettingsSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_IMAGESETTINGS_SERVERGROUPIMAGESETTINGS_CONTROLLER } from './wizard/image/ServerGroupImageSettings.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_IMAGESETTINGS_IMAGESETTINGS_DIRECTIVE } from './wizard/image/imageSettingsSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_LOADBALANCERS_SERVERGROUPLOADBALANCERS_CONTROLLER } from './wizard/loadBalancers/ServerGroupLoadBalancers.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_LOADBALANCERS_SERVERGROUPLOADBALANCERSSELECTOR_DIRECTIVE } from './wizard/loadBalancers/serverGroupLoadBalancersSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_NETWORKSETTINGS_SERVERGROUPNETWORKSETTINGS_CONTROLLER } from './wizard/networkSettings/ServerGroupNetworkSettings.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_NETWORKSETTINGS_SERVERGROUPNETWORKSETTINGSSELECTOR_DIRECTIVE } from './wizard/networkSettings/ServerGroupNetworkSettingsSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_SECURITYGROUP_SERVERGROUPSECURITYGROUPS_CONTROLLER } from './wizard/securityGroup/ServerGroupSecurityGroups.controller';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_SECURITYGROUP_SERVERGROUPSECURITYGROUPSSELECTOR_DIRECTIVE } from './wizard/securityGroup/serverGroupSecurityGroupsSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_TAGS_TAGSSELECTOR_DIRECTIVE } from './wizard/tags/tagsSelector.directive';
+import { AZURE_SERVERGROUP_CONFIGURE_WIZARD_ZONES_ZONESELECTOR_DIRECTIVE } from './wizard/zones/zoneSelector.directive';
+
+('use strict');
+
+export const AZURE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_AZURE_MODULE = 'spinnaker.azure.serverGroup.configure';
+export const name = AZURE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_AZURE_MODULE; // for backwards compatibility
+module(AZURE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_AZURE_MODULE, [
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_BASICSETTINGS_SERVERGROUPBASICSETTINGS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_LOADBALANCERS_SERVERGROUPLOADBALANCERS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_SERVERGROUPINSTANCEARCHETYPE_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_SERVERGROUPINSTANCETYPE_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_SECURITYGROUP_SERVERGROUPSECURITYGROUPS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_SERVERGROUPADVANCEDSETTINGS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_HEALTHSETTINGS_HEALTHSETTINGSSELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_IMAGESETTINGS_IMAGESETTINGS_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_IMAGESETTINGS_SERVERGROUPIMAGESETTINGS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_HEALTHSETTINGS_SERVERGROUPHEALTHSETTINGS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_LOADBALANCERS_SERVERGROUPLOADBALANCERSSELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_CAPACITY_CAPACITYSELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_SECURITYGROUP_SERVERGROUPSECURITYGROUPSSELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_ADVANCEDSETTINGSSELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_NETWORKSETTINGS_SERVERGROUPNETWORKSETTINGS_CONTROLLER,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_NETWORKSETTINGS_SERVERGROUPNETWORKSETTINGSSELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_ZONES_ZONESELECTOR_DIRECTIVE,
+  AZURE_SERVERGROUP_CONFIGURE_WIZARD_TAGS_TAGSSELECTOR_DIRECTIVE,
+]);

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

@@ -0,0 +1,175 @@
+'use strict';
+
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import { NameUtils } from '@spinnaker/core';
+import { AZURE_IMAGE_IMAGE_READER } from '../../image/image.reader';
+import { AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER } from '../serverGroup.transformer';
+
+export const AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE =
+  'spinnaker.azure.serverGroupCommandBuilder.service';
+export const name = AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE; // for backwards compatibility
+angular
+  .module(AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE, [
+    AZURE_IMAGE_IMAGE_READER,
+    AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER,
+  ])
+  .factory('azureServerGroupCommandBuilder', [
+    '$q',
+    'azureImageReader',
+    'azureServerGroupTransformer',
+    function ($q, azureImageReader, azureServerGroupTransformer) {
+      function buildNewServerGroupCommand(application, defaults) {
+        defaults = defaults || {};
+
+        const defaultCredentials = defaults.account || application.defaultCredentials.azure;
+        const defaultRegion = defaults.region || application.defaultRegions.azure;
+
+        return azureImageReader.findImages({ provider: 'azure' }).then(function (images) {
+          return {
+            application: application.name,
+            credentials: defaultCredentials,
+            region: defaultRegion,
+            images,
+            loadBalancers: [],
+            selectedVnetSubnets: [],
+            strategy: '',
+            sku: {
+              capacity: 1,
+            },
+            zonesEnabled: false,
+            zones: [],
+            instanceTags: {},
+            dataDisks: [],
+            selectedProvider: 'azure',
+            viewState: {
+              instanceProfile: 'custom',
+              allImageSelection: null,
+              useAllImageSelection: false,
+              useSimpleCapacity: true,
+              usePreferredZones: true,
+              mode: defaults.mode || 'create',
+              disableStrategySelection: true,
+              loadBalancersConfigured: false,
+              networkSettingsConfigured: false,
+              securityGroupsConfigured: false,
+            },
+            enableInboundNAT: false,
+          };
+        });
+      }
+
+      // Only used to prepare view requiring template selecting
+      function buildNewServerGroupCommandForPipeline() {
+        return $q.when({
+          viewState: {
+            requiresTemplateSelection: true,
+          },
+        });
+      }
+
+      function buildServerGroupCommandFromExisting(application, serverGroup, mode) {
+        mode = mode || 'clone';
+
+        const serverGroupName = NameUtils.parseServerGroupName(serverGroup.name);
+
+        const command = {
+          application: application.name,
+          strategy: '',
+          stack: serverGroupName.stack,
+          freeFormDetails: serverGroupName.freeFormDetails,
+          credentials: serverGroup.account,
+          loadBalancers: serverGroup.loadBalancers,
+          selectedSubnets: serverGroup.selectedVnetSubnets,
+          selectedVnet: serverGroup.selectedVnet,
+          securityGroups: serverGroup.securityGroups,
+          loadBalancerName: serverGroup.loadBalancerName,
+          loadBalancerType: serverGroup.loadBalancerType,
+          securityGroupName: serverGroup.securityGroupName,
+          region: serverGroup.region,
+          vnet: serverGroup.vnet,
+          vnetResourceGroup: serverGroup.vnetResourceGroup,
+          subnet: serverGroup.subnet,
+          zones: serverGroup.zones,
+          zonesEnabled: serverGroup.zones && serverGroup.zones.length > 0,
+          instanceTags: {},
+          dataDisks: serverGroup.dataDisks,
+          sku: serverGroup.sku,
+          capacity: {
+            min: serverGroup.capacity.min,
+            max: serverGroup.capacity.max,
+            desired: serverGroup.capacity.desired,
+          },
+          tags: [],
+          instanceType: serverGroup.sku.name,
+          selectedProvider: 'azure',
+          source: {
+            account: serverGroup.account,
+            region: serverGroup.region,
+            serverGroupName: serverGroup.name,
+            asgName: serverGroup.name,
+          },
+          viewState: {
+            allImageSelection: null,
+            useAllImageSelection: false,
+            useSimpleCapacity: true,
+            usePreferredZones: false,
+            listImplicitSecurityGroups: false,
+            mode: mode,
+            disableStrategySelection: true,
+          },
+          enableInboundNAT: serverGroup.enableInboundNAT,
+        };
+
+        if (typeof serverGroup.customScriptsSettings !== 'undefined') {
+          command.customScriptsSettings = {};
+          command.customScriptsSettings.commandToExecute = serverGroup.customScriptsSettings.commandToExecute;
+          if (!_.isEmpty(serverGroup.customScriptsSettings.fileUris)) {
+            azureServerGroupTransformer.parseCustomScriptsSettings(serverGroup, command);
+          }
+        }
+
+        return $q.when(command);
+      }
+
+      function buildServerGroupCommandFromPipeline(application, originalCluster) {
+        const pipelineCluster = _.cloneDeep(originalCluster);
+        const region = pipelineCluster.region;
+
+        const commandOptions = { account: pipelineCluster.account, region: region };
+        return buildNewServerGroupCommand(application, commandOptions).then(function (command) {
+          const viewState = {
+            disableImageSelection: true,
+            useSimpleCapacity: true,
+            mode: 'editPipeline',
+            submitButtonLabel: 'Done',
+            instanceProfile: originalCluster.viewState.instanceProfile,
+            instanceTypeDetails: originalCluster.viewState.instanceTypeDetails,
+          };
+
+          const viewOverrides = {
+            region: region,
+            credentials: pipelineCluster.account,
+            viewState: viewState,
+          };
+          if (originalCluster.viewState.instanceTypeDetails) {
+            viewOverrides.instanceType = originalCluster.viewState.instanceTypeDetails.name;
+          }
+
+          pipelineCluster.strategy = pipelineCluster.strategy || '';
+
+          const extendedCommand = angular.extend({}, command, pipelineCluster, viewOverrides);
+
+          return extendedCommand;
+        });
+      }
+
+      return {
+        buildNewServerGroupCommand: buildNewServerGroupCommand,
+        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
+        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
+        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
+      };
+    },
+  ]);

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

@@ -0,0 +1,357 @@
+'use strict';
+
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import {
+  AccountService,
+  CACHE_INITIALIZER_SERVICE,
+  LOAD_BALANCER_READ_SERVICE,
+  SECURITY_GROUP_READER,
+} from '@spinnaker/core';
+import { AZURE_IMAGE_IMAGE_READER } from '../../image/image.reader';
+import { AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE } from '../../instance/azureInstanceType.service';
+
+export const AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE =
+  'spinnaker.azure.serverGroup.configure.service';
+export const name = AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE; // for backwards compatibility
+angular
+  .module(AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE, [
+    AZURE_IMAGE_IMAGE_READER,
+    LOAD_BALANCER_READ_SERVICE,
+    SECURITY_GROUP_READER,
+    CACHE_INITIALIZER_SERVICE,
+    AZURE_INSTANCE_AZUREINSTANCETYPE_SERVICE,
+  ])
+  .factory('azureServerGroupConfigurationService', [
+    '$q',
+    'azureImageReader',
+    'securityGroupReader',
+    'cacheInitializer',
+    'loadBalancerReader',
+    'azureInstanceTypeService',
+    function (
+      $q,
+      azureImageReader,
+      securityGroupReader,
+      cacheInitializer,
+      loadBalancerReader,
+      azureInstanceTypeService,
+    ) {
+      const dataDiskTypes = ['Standard_LRS', 'StandardSSD_LRS', 'Premium_LRS'];
+      const dataDiskCachingTypes = ['None', 'ReadOnly', 'ReadWrite'];
+
+      const healthCheckTypes = ['EC2', 'ELB'];
+      const terminationPolicies = [
+        'OldestInstance',
+        'NewestInstance',
+        'OldestLaunchConfiguration',
+        'ClosestToNextInstanceHour',
+        'Default',
+      ];
+
+      function configureUpdateCommand(command) {
+        command.backingData = {
+          healthCheckTypes: angular.copy(healthCheckTypes),
+          terminationPolicies: angular.copy(terminationPolicies),
+        };
+      }
+
+      function configureCommand(application, command) {
+        return $q
+          .all([
+            AccountService.getCredentialsKeyedByAccount('azure'),
+            securityGroupReader.loadSecurityGroups(),
+            loadBalancerReader.loadLoadBalancers(application.name),
+          ])
+          .then(function ([credentialsKeyedByAccount, securityGroups, loadBalancers]) {
+            command.backingData = {
+              credentialsKeyedByAccount,
+              securityGroups,
+              loadBalancers,
+              dataDiskTypes: angular.copy(dataDiskTypes),
+              dataDiskCachingTypes: angular.copy(dataDiskCachingTypes),
+              accounts: _.keys(credentialsKeyedByAccount),
+              filtered: {},
+            };
+            attachEventHandlers(command);
+          });
+      }
+
+      function configureInstanceTypes(command) {
+        const result = {
+          dirty: {},
+        };
+        if (command.region) {
+          const results = [result.dirty];
+
+          // results.push(configureCustomInstanceTypes(command).dirty);
+          results.push(configureStandardInstanceTypes(command).dirty);
+
+          angular.extend(...results);
+        } else {
+          command.backingData.filtered.instanceTypes = [];
+        }
+        return result;
+      }
+
+      function configureStandardInstanceTypes(command) {
+        const c = command;
+        const result = {
+          dirty: {},
+        };
+
+        const locations = [c.region];
+        const { credentialsKeyedByAccount } = c.backingData;
+        const { locationToInstanceTypesMap } = credentialsKeyedByAccount[c.credentials];
+
+        if (locations.every((l) => !l)) {
+          return result;
+        }
+
+        const filtered = azureInstanceTypeService
+          .getAvailableTypesForRegions(locationToInstanceTypesMap, locations)
+          .map((type) => type.name);
+
+        const instanceType = c.instanceType;
+        if (_.every([instanceType, !_.startsWith(instanceType, 'custom'), !_.includes(filtered, instanceType)])) {
+          result.dirty.instanceType = c.instanceType;
+          c.instanceType = null;
+        }
+        c.backingData.filtered.instanceTypes = filtered;
+        return result;
+      }
+
+      function configureImages(command) {
+        const result = {
+          dirty: {},
+        };
+        let regionalImages = null;
+        if (command.viewState.disableImageSelection) {
+          return result;
+        }
+        if (command.region) {
+          regionalImages = command.backingData.packageImages
+            .filter(function (image) {
+              return image.amis && image.amis[command.region];
+            })
+            .map(function (image) {
+              return {
+                imageName: image.imageName,
+                ami: image.amis ? image.amis[command.region][0] : null,
+              };
+            });
+          if (
+            command.amiName &&
+            !regionalImages.some(function (image) {
+              return image.imageName === command.amiName;
+            })
+          ) {
+            result.dirty.amiName = true;
+            command.amiName = null;
+          }
+        } else {
+          command.amiName = null;
+        }
+        command.backingData.filtered.images = regionalImages;
+        return result;
+      }
+
+      function configureZones(command) {
+        const result = { dirty: {} };
+        const filteredData = command.backingData.filtered;
+        if (!command.region) {
+          return result;
+        }
+        let { regionsSupportZones, availabilityZones } = command.backingData.credentialsKeyedByAccount[
+          command.credentials
+        ];
+        regionsSupportZones = regionsSupportZones || [];
+        availabilityZones = availabilityZones || [];
+        filteredData.zones = regionsSupportZones.includes(command.region) ? availabilityZones : [];
+
+        return result;
+      }
+
+      function getRegionalSecurityGroups(command) {
+        const newSecurityGroups = command.backingData.securityGroups[command.credentials] || {
+          azure: {},
+        };
+        return _.chain(newSecurityGroups[command.region]).sortBy('name').value();
+      }
+
+      function configureSecurityGroupOptions(command) {
+        const result = {
+          dirty: {},
+        };
+        let currentOptions;
+        if (command.backingData.filtered.securityGroups) {
+          currentOptions = command.backingData.filtered.securityGroups;
+        }
+        const newRegionalSecurityGroups = getRegionalSecurityGroups(command);
+        if (command.selectedSecurityGroup) {
+          // one has not been previously selected. We are either configuring for the
+          //first time or they changed regions or account
+          command.selectedSecurityGroup = null;
+          result.dirty.securityGroups = true;
+        }
+        if (currentOptions != newRegionalSecurityGroups) {
+          command.backingData.filtered.securityGroups = newRegionalSecurityGroups;
+          result.dirty.securityGroups = true;
+        }
+
+        if (command.backingData.filtered.securityGroups === []) {
+          command.viewState.securityGroupsConfigured = false;
+        } else {
+          command.viewState.securityGroupsConfigured = true;
+        }
+
+        return result;
+      }
+
+      function refreshSecurityGroups(command, skipCommandReconfiguration) {
+        return cacheInitializer.refreshCache('securityGroups').then(function () {
+          return securityGroupReader.getAllSecurityGroups().then(function (securityGroups) {
+            command.backingData.securityGroups = securityGroups;
+            if (!skipCommandReconfiguration) {
+              configureSecurityGroupOptions(command);
+            }
+          });
+        });
+      }
+
+      function getLoadBalancerNames(loadBalancers) {
+        return _.chain(loadBalancers).map('name').uniq().value().sort();
+      }
+
+      function configureLoadBalancerOptions(command) {
+        const result = {
+          dirty: {},
+        };
+        const current = command.loadBalancers;
+        const newLoadBalancers = getLoadBalancerNames(command.backingData.loadBalancers);
+
+        if (current && command.loadBalancers) {
+          const matched = _.intersection(newLoadBalancers, command.loadBalancers);
+          const removed = _.xor(matched, current);
+          command.loadBalancers = matched;
+          if (removed.length) {
+            result.dirty.loadBalancers = removed;
+          }
+        }
+        command.backingData.filtered.loadBalancers = newLoadBalancers;
+        return result;
+      }
+
+      function refreshLoadBalancers(command, skipCommandReconfiguration) {
+        return loadBalancerReader.listLoadBalancers('azure').then(function (loadBalancers) {
+          command.backingData.loadBalancers = loadBalancers;
+          if (!skipCommandReconfiguration) {
+            configureLoadBalancerOptions(command);
+          }
+        });
+      }
+
+      function configureLoadBalancers(command) {
+        const result = {
+          dirty: {},
+        };
+        const temp = command.backingData.loadBalancers;
+        const filterlist = _.filter(temp, function (lb) {
+          return lb.account === command.credentials && lb.region === command.region;
+        });
+
+        command.loadBalancers = getLoadBalancerNames(filterlist);
+        command.viewState.loadBalancersConfigured = true;
+
+        return result;
+      }
+
+      function attachEventHandlers(cmd) {
+        cmd.regionChanged = function regionChanged(command, isInit = false) {
+          const result = {
+            dirty: {},
+          };
+          if (command.region && command.credentials) {
+            angular.extend(result.dirty, configureLoadBalancers(command).dirty);
+            angular.extend(result.dirty, configureSecurityGroupOptions(command).dirty);
+            angular.extend(result.dirty, configureInstanceTypes(command).dirty);
+            angular.extend(result.dirty, configureZones(command).dirty);
+          }
+          // reset previous set values
+          if (!isInit) {
+            command.loadBalancerName = null;
+            command.loadBalancerType = null;
+            command.vnet = null;
+            command.vnetResourceGroup = null;
+            command.subnet = null;
+            command.selectedSubnet = null;
+            command.selectedVnet = null;
+            command.selectedVnetSubnets = [];
+            command.viewState.networkSettingsConfigured = false;
+            command.selectedSecurityGroup = null;
+            command.securityGroupName = null;
+            command.zonesEnabled = false;
+            command.zones = [];
+          }
+
+          return result;
+        };
+
+        cmd.credentialsChanged = function credentialsChanged(command, isInit) {
+          const result = {
+            dirty: {},
+          };
+          const backingData = command.backingData;
+          if (command.credentials) {
+            const regionsForAccount = backingData.credentialsKeyedByAccount[command.credentials] || {
+              regions: [],
+              defaultKeyPair: null,
+            };
+            backingData.filtered.regions = regionsForAccount.regions;
+            if (
+              !_.chain(backingData.filtered.regions)
+                .some({
+                  name: command.region,
+                })
+                .value()
+            ) {
+              command.region = null;
+              result.dirty.region = true;
+            } else {
+              angular.extend(result.dirty, command.regionChanged(command, isInit).dirty);
+            }
+            if (command.region) {
+              angular.extend(result.dirty, configureLoadBalancers(command).dirty);
+            }
+            angular.extend(result.dirty, configureInstanceTypes(command).dirty);
+          } else {
+            command.region = null;
+          }
+          return result;
+        };
+      }
+
+      function refreshInstanceTypes(command) {
+        return cacheInitializer.refreshCache('instanceTypes').then(function () {
+          return azureInstanceTypeService.getAllTypesByRegion().then(function (instanceTypes) {
+            command.backingData.instanceTypes = instanceTypes;
+            configureInstanceTypes(command);
+          });
+        });
+      }
+
+      return {
+        configureUpdateCommand: configureUpdateCommand,
+        configureCommand: configureCommand,
+        configureImages: configureImages,
+        configureSecurityGroupOptions: configureSecurityGroupOptions,
+        configureLoadBalancerOptions: configureLoadBalancerOptions,
+        refreshLoadBalancers: refreshLoadBalancers,
+        refreshSecurityGroups: refreshSecurityGroups,
+        getRegionalSecurityGroups: getRegionalSecurityGroups,
+        refreshInstanceTypes: refreshInstanceTypes,
+        configureZones: configureZones,
+      };
+    },
+  ]);