@spinnaker/google 0.0.0-main-2

package/src/loadBalancer/configure/http/backendService/backendServices.html

@@ -0,0 +1,57 @@
+<ng-form name="backendServices">
+  <div class="col-md-12" ng-if="ctrl.command.getUnusedBackendServices(ctrl.command).length">
+    <div class="alert alert-warning">
+      <p>
+        <i class="fa fa-exclamation-triangle"></i>
+        The following backend services have not been associated with a host or path rule, or set as this load balancer's
+        default service:
+      </p>
+      <ul>
+        <li ng-repeat="service in ctrl.command.getUnusedBackendServices(ctrl.command)" ng-bind-html="service"></li>
+      </ul>
+      <p class="text-right">
+        <a
+          class="btn btn-sm btn-default dirty-flag-dismiss"
+          href
+          ng-click="ctrl.command.removeUnusedBackendServices(ctrl.command)"
+          >Remove backend services</a
+        >
+      </p>
+    </div>
+  </div>
+  <div
+    class="col-md-12"
+    ng-if="!ctrl.command.loadBalancer.backendServices.length && !ctrl.command.backingData.backendServices.length"
+  >
+    <div class="alert alert-warning">
+      <p>
+        <i class="fa fa-exclamation-triangle"></i>
+        You have not configured any backend services.
+      </p>
+    </div>
+  </div>
+  <gce-http-load-balancer-backend-service-selector
+    ng-repeat="backendService in ctrl.command.loadBalancer.backendServices"
+    backend-service="backendService"
+    index="$index"
+    command="ctrl.command"
+    delete-service="ctrl.remove('backendServices', $index)"
+  >
+  </gce-http-load-balancer-backend-service-selector>
+  <div class="row">
+    <div class="col-md-12">
+      <button class="add-new btn btn-block" ng-click="ctrl.add('backendServices')">
+        <span class="glyphicon glyphicon-plus-sign"></span> Add backend service
+      </button>
+    </div>
+  </div>
+  <div class="form-group small" style="margin-top: 20px">
+    <div class="col-md-offset-2 col-md-6">
+      <gce-cache-refresh
+        cache-key="backendServices"
+        cache-key-alias="backend services"
+        on-refresh="ctrl.command.onBackendServiceRefresh(ctrl.command)"
+      ></gce-cache-refresh>
+    </div>
+  </div>
+</ng-form>

package/src/loadBalancer/configure/http/basicSettings/basicSettings.component.html

@@ -0,0 +1,105 @@
+<div class="container-fluid form-horizontal">
+  <ng-form name="basicSettings">
+    <div class="modal-body">
+      <div class="form-group">
+        <div
+          class="col-md-12 well"
+          ng-class="{
+            'alert-danger': basicSettings.urlMapName.$error.validateUnique,
+            'alert-info': !basicSettings.urlMapName.$error.validateUnique
+          }"
+        >
+          <strong>Your load balancer will be named:</strong>
+          <span>{{ $ctrl.getName($ctrl.loadBalancer, $ctrl.application.name) }}</span>
+          <!-- Angular does not seem to run length validation on hidden inputs, hence the text + display:none -->
+          <input
+            type="text"
+            style="display: none"
+            ng-maxlength="63"
+            class="form-control input-sm"
+            ng-model="$ctrl.loadBalancer.urlMapName"
+            validate-unique="$ctrl.existingLoadBalancerNames"
+            validate-ignore-case="true"
+            name="urlMapName"
+          />
+          <validation-error
+            ng-if="basicSettings.urlMapName.$error.validateUnique"
+            message="There is already a load balancer in {{ $ctrl.loadBalancer.credentials }} with that name."
+          >
+          </validation-error>
+        </div>
+      </div>
+      <div class="form-group">
+        <div class="col-md-2 sm-label-right">Account</div>
+        <div class="col-md-8">
+          <account-select-field
+            component="$ctrl.loadBalancer"
+            field="credentials"
+            accounts="$ctrl.accounts"
+            provider="'gce'"
+            on-change="$ctrl.accountChanged($ctrl.loadBalancer.credentials)"
+          >
+          </account-select-field>
+        </div>
+      </div>
+      <gce-region-select-field
+        ng-if="$ctrl.loadBalancer.loadBalancerType === 'INTERNAL_MANAGED'"
+        label-columns="2"
+        field-columns="8"
+        component="$ctrl.loadBalancer"
+        field="region"
+        account="$ctrl.loadBalancer.credentials"
+        on-change="$ctrl.command.onRegionSelected($ctrl.command)"
+        regions="$ctrl.command.backingData.regions"
+      ></gce-region-select-field>
+      <gce-network-select-field
+        ng-if="$ctrl.loadBalancer.loadBalancerType === 'INTERNAL_MANAGED'"
+        label-columns="2"
+        field-columns="8"
+        component="$ctrl.loadBalancer"
+        field="network"
+        helpKey="gce.internalHttpLoadBalancer.network"
+        account="$ctrl.loadBalancer.credentials"
+        networks="$ctrl.command.backingData.internalHttpLbNetworks"
+      ></gce-network-select-field>
+
+      <div class="form-group">
+        <div class="col-md-2 sm-label-right">Stack <help-field key="aws.loadBalancer.stack"></help-field></div>
+        <div class="col-md-3">
+          <input
+            type="text"
+            class="form-control input-sm"
+            ng-model="$ctrl.loadBalancer.stack"
+            name="stackName"
+            ng-change="$ctrl.updateName($ctrl.loadBalancer, $ctrl.application.name)"
+            ng-pattern="/^[a-z0-9]*$/"
+          />
+        </div>
+        <div class="col-md-2 sm-label-right">Detail<help-field key="gce.loadBalancer.detail"></help-field></div>
+        <div class="col-md-3">
+          <input
+            type="text"
+            class="form-control input-sm"
+            ng-model="$ctrl.loadBalancer.detail"
+            name="detailName"
+            ng-change="$ctrl.updateName($ctrl.loadBalancer, $ctrl.application.name)"
+            ng-pattern="/^[a-z0-9-]*$/"
+          />
+        </div>
+        <div class="col-md-7 col-md-offset-3" ng-if="basicSettings.stackName.$error.pattern">
+          <validation-error message="Stack can only contain lowercase letters and numbers."></validation-error>
+        </div>
+        <div class="col-md-7 col-md-offset-3" ng-if="basicSettings.detailName.$error.pattern">
+          <validation-error
+            message="Detail can only contain lowercase letters, numbers, and dashes(-)."
+          ></validation-error>
+        </div>
+      </div>
+      <div class="form-group">
+        <div class="col-md-9 col-md-offset-3" ng-if="basicSettings.urlMapName.$error.maxlength">
+          <validation-error message="Load Balancer name can only be 63 characters."></validation-error>
+        </div>
+      </div>
+    </div>
+  </ng-form>
+</div>

package/src/loadBalancer/configure/http/basicSettings/basicSettings.component.js

@@ -0,0 +1,46 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BASICSETTINGS_BASICSETTINGS_COMPONENT =
+  'spinnaker.deck.gce.httpLoadBalancer.basicSettings.component';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BASICSETTINGS_BASICSETTINGS_COMPONENT; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BASICSETTINGS_BASICSETTINGS_COMPONENT, []).component(
+  'gceHttpLoadBalancerBasicSettings',
+  {
+    bindings: {
+      command: '=',
+      application: '=',
+    },
+    templateUrl: require('./basicSettings.component.html'),
+    controller: function () {
+      this.$onInit = () => {
+        const c = this.command;
+        this.loadBalancer = c.loadBalancer;
+        this.accounts = c.backingData.accounts;
+        const loadBalancerMap = c.backingData.loadBalancerMap;
+
+        this.getName = (loadBalancer, applicationName) => {
+          const loadBalancerName = [applicationName, loadBalancer.stack || '', loadBalancer.detail || ''].join('-');
+          return _.trimEnd(loadBalancerName, '-');
+        };
+
+        this.updateName = (lb, appName) => {
+          lb.urlMapName = this.getName(lb, appName);
+        };
+
+        this.accountChanged = (account) => {
+          this.existingLoadBalancerNames = _.get(loadBalancerMap, [account, 'urlMapNames']) || [];
+          c.onAccountChange(c);
+        };
+
+        if (!this.loadBalancer.name) {
+          this.updateName(this.loadBalancer, this.application.name);
+        }
+
+        this.existingLoadBalancerNames = _.get(loadBalancerMap, [this.loadBalancer.credentials, 'urlMapNames']) || [];
+      };
+    },
+  },
+);

package/src/loadBalancer/configure/http/basicSettings/basicSettings.html

@@ -0,0 +1,6 @@
+<ng-form name="location">
+  <gce-http-load-balancer-basic-settings
+    application="ctrl.application"
+    command="ctrl.command"
+  ></gce-http-load-balancer-basic-settings>
+</ng-form>

package/src/loadBalancer/configure/http/commandBuilder.service.js

@@ -0,0 +1,404 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { AccountService, LOAD_BALANCER_READ_SERVICE, NetworkReader, SubnetReader } from '@spinnaker/core';
+
+import { GCE_ADDRESS_READER } from '../../../address/address.reader';
+import { GOOGLE_BACKENDSERVICE_BACKENDSERVICE_READER } from '../../../backendService/backendService.reader';
+import { GCE_CERTIFICATE_READER } from '../../../certificate/certificate.reader';
+import { sessionAffinityModelToViewMap } from '../common/sessionAffinityNameMaps';
+import { GOOGLE_COMMON_XPNNAMING_GCE_SERVICE } from '../../../common/xpnNaming.gce.service';
+import { GCEProviderSettings } from '../../../gce.settings';
+import { GCE_HEALTH_CHECK_READER } from '../../../healthCheck/healthCheck.read.service';
+import { GCE_HTTP_LOAD_BALANCER_UTILS } from '../../httpLoadBalancerUtils.service';
+import { HttpLoadBalancerTemplate, ListenerTemplate } from './templates';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE } from './transformer.service';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_COMMANDBUILDER_SERVICE =
+  'spinnaker.deck.gce.httpLoadBalancer.backing.service';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_COMMANDBUILDER_SERVICE; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_COMMANDBUILDER_SERVICE, [
+  GOOGLE_BACKENDSERVICE_BACKENDSERVICE_READER,
+  GCE_CERTIFICATE_READER,
+  LOAD_BALANCER_READ_SERVICE,
+  GCE_HTTP_LOAD_BALANCER_UTILS,
+  GCE_ADDRESS_READER,
+  GCE_HEALTH_CHECK_READER,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE,
+  GOOGLE_COMMON_XPNNAMING_GCE_SERVICE,
+]).factory('gceHttpLoadBalancerCommandBuilder', [
+  '$q',
+  'gceHttpLoadBalancerUtils',
+  'gceBackendServiceReader',
+  'gceCertificateReader',
+  'gceHealthCheckReader',
+  'gceHttpLoadBalancerTransformer',
+  'loadBalancerReader',
+  'gceAddressReader',
+  'gceXpnNamingService',
+  function (
+    $q,
+    gceHttpLoadBalancerUtils,
+    gceBackendServiceReader,
+    gceCertificateReader,
+    gceHealthCheckReader,
+    gceHttpLoadBalancerTransformer,
+    loadBalancerReader,
+    gceAddressReader,
+    gceXpnNamingService,
+  ) {
+    function buildCommand({ originalLoadBalancer, isNew, isInternal }) {
+      originalLoadBalancer = _.cloneDeep(originalLoadBalancer);
+
+      return buildBackingDataAndLoadBalancer(originalLoadBalancer, isNew, isInternal).then(
+        ({ backingData, loadBalancer }) => {
+          return {
+            backingData,
+            getAllBackendServices,
+            isNew,
+            loadBalancer,
+            onAccountChange,
+            onBackendServiceRefresh,
+            onBackendServiceSelected,
+            onRegionSelected,
+            onCertificateRefresh,
+            onHealthCheckRefresh,
+            onHealthCheckSelected,
+            getUnusedBackendServices,
+            removeUnusedBackendServices,
+            getUnusedHealthChecks,
+            removeUnusedHealthChecks,
+            onAddressRefresh,
+          };
+        },
+      );
+    }
+
+    function buildBackingDataAndLoadBalancer(originalLoadBalancer, isNew, isInternal) {
+      let region = null;
+      if (isInternal) {
+        region = originalLoadBalancer ? originalLoadBalancer.region : GCEProviderSettings.defaults.region;
+      }
+      return buildBackingData(region).then((backingData) => {
+        const loadBalancer = buildLoadBalancer(isNew, originalLoadBalancer, isInternal);
+
+        unifyDataSources(backingData, loadBalancer);
+
+        return { backingData, loadBalancer };
+      });
+    }
+
+    function buildBackingData(region) {
+      const promises = {
+        backendServices: getBackendServices(region),
+        healthChecks: getHealthChecks(region),
+        certificates: getCertificates(),
+        loadBalancerMap: getLoadBalancerMap(region),
+        networks: getNetworks(),
+        subnets: SubnetReader.listSubnetsByProvider('gce'),
+        addresses: gceAddressReader.listAddresses(region),
+        accounts: getAccounts(),
+      };
+      return $q.all(promises);
+    }
+
+    function buildLoadBalancer(isNew, loadBalancer, isInternal) {
+      const loadBalancerTemplate = new HttpLoadBalancerTemplate(GCEProviderSettings.defaults.account || null);
+      if (isInternal) {
+        loadBalancerTemplate.loadBalancerType = 'INTERNAL_MANAGED';
+        loadBalancerTemplate.isInternal = true;
+        if (loadBalancer) {
+          loadBalancer.network = gceXpnNamingService.decorateXpnResourceIfNecessary(
+            loadBalancer.project,
+            loadBalancer.network,
+          );
+          loadBalancer.listeners.forEach((listener) => {
+            listener.subnet = gceXpnNamingService.decorateXpnResourceIfNecessary(loadBalancer.project, listener.subnet);
+          });
+        }
+        loadBalancerTemplate.region = GCEProviderSettings.defaults.region;
+        loadBalancerTemplate.network = 'default';
+      } else {
+        loadBalancerTemplate.loadBalancerType = 'HTTP';
+        loadBalancerTemplate.isInternal = false;
+      }
+
+      let mixinData;
+      if (isNew) {
+        mixinData = {
+          backendServices: [],
+          listeners: [new ListenerTemplate()],
+          healthChecks: [],
+        };
+      } else {
+        mixinData = gceHttpLoadBalancerTransformer.deserialize(loadBalancer);
+      }
+
+      const loadBalancerData = _.assign(loadBalancerTemplate, mixinData);
+      return loadBalancerData;
+    }
+
+    function unifyDataSources(backingData, loadBalancer) {
+      setAccount(backingData.accounts, loadBalancer);
+      removeExistingListenersFromBackingData(backingData, loadBalancer.listeners);
+
+      // update backing data with any values coming from load balancer -- they are more up to date.
+      const lbHealthCheckMap = _.keyBy(loadBalancer.healthChecks, 'name');
+      const backingDataHealthCheckMap = _.keyBy(backingData.healthChecks, 'name');
+
+      backingData.healthChecksKeyedByName = _.assign(backingDataHealthCheckMap, _.cloneDeep(lbHealthCheckMap));
+      backingData.healthChecksKeyedByNameCopy = _.cloneDeep(backingDataHealthCheckMap);
+      backingData.healthChecks = _.map(backingDataHealthCheckMap, _.identity);
+
+      const lbBackendServicesMap = _.keyBy(loadBalancer.backendServices, 'name');
+      const backingDataBackendServiceMap = _.keyBy(backingData.backendServices, 'name');
+
+      backingData.backendServicesKeyedByName = _.assign(
+        backingDataBackendServiceMap,
+        _.cloneDeep(lbBackendServicesMap),
+      );
+      backingData.backendServicesKeyedByNameCopy = _.cloneDeep(backingDataBackendServiceMap);
+      backingData.backendServices = _.map(backingDataBackendServiceMap, _.identity);
+
+      backingData.regions = backingData.accounts
+        .find((account) => account.name === loadBalancer.credentials)
+        .regions.map((region) => region.name);
+
+      backingData.subnetMap = _.groupBy(backingData.subnets, 'network');
+      backingData.internalHttpLbNetworks = backingData.networks.filter((network) =>
+        backingData.subnetMap[network].find((subnet) => subnet.purpose === 'INTERNAL_HTTPS_LOAD_BALANCER'),
+      );
+    }
+
+    function removeExistingListenersFromBackingData(backingData, existingListeners) {
+      const accountNames = backingData.accounts.map((account) => account.name);
+
+      accountNames.forEach((accountName) => {
+        if (_.has(backingData, ['loadBalancerMap', accountName, 'listeners'])) {
+          backingData.loadBalancerMap[accountName].listeners = _.without(
+            backingData.loadBalancerMap[accountName].listeners,
+            ...existingListeners.map((listener) => listener.name),
+          );
+        }
+      });
+    }
+
+    function setAccount(accounts, loadBalancerData) {
+      const accountNames = _.map(accounts, 'name');
+      const credentials = _.get(loadBalancerData, 'credentials.name') || loadBalancerData.credentials;
+
+      if (!accountNames.includes(credentials)) {
+        loadBalancerData.credentials = _.first(accountNames);
+      }
+    }
+
+    function getHealthChecks(region) {
+      return gceHealthCheckReader.listHealthChecks().then((healthChecks) => {
+        return healthChecks.filter((healthCheck) => !region || healthCheck.region === region);
+      });
+    }
+
+    function getNetworks() {
+      return NetworkReader.listNetworksByProvider('gce').then((networks) => {
+        return _.chain(networks).map('name').compact().uniq().value();
+      });
+    }
+
+    function getBackendServices(region) {
+      const kind = region ? 'regionBackendService' : 'globalBackendService';
+      return gceBackendServiceReader.listBackendServices(kind).then((backendServices) => {
+        backendServices = backendServices.filter((backendService) => !region || backendService.region === region);
+        backendServices.forEach((service) => {
+          service.healthCheck = service.healthCheckLink.split('/').pop();
+
+          const ttlIsDefined = typeof service.affinityCookieTtlSec === 'string';
+          service.affinityCookieTtlSec = ttlIsDefined ? Number(service.affinityCookieTtlSec) : null;
+
+          service.sessionAffinity = sessionAffinityModelToViewMap[service.sessionAffinity] || service.sessionAffinity;
+        });
+
+        return backendServices;
+      });
+    }
+
+    function getCertificates() {
+      return gceCertificateReader.listCertificates();
+    }
+
+    function getAccounts() {
+      return AccountService.listAccounts('gce');
+    }
+
+    function getLoadBalancerMap(region) {
+      return loadBalancerReader.listLoadBalancers('gce').then((lbs) => {
+        return _.chain(lbs)
+          .map((lb) => lb.accounts)
+          .flatten()
+          .groupBy('name')
+          .mapValues((accounts) => {
+            const loadBalancers = _.chain(accounts)
+              .map((a) => a.regions)
+              .flatten()
+              .filter((region) => region.name === (region || gceHttpLoadBalancerUtils.REGION))
+              .map((region) => region.loadBalancers)
+              .flatten()
+              .value();
+
+            const urlMapNames = _.chain(loadBalancers).map('urlMapName').uniq().value();
+            const listeners = _.chain(loadBalancers).map('name').uniq().value();
+
+            return { urlMapNames, listeners };
+          })
+          .valueOf();
+      });
+    }
+
+    function onHealthCheckRefresh(command) {
+      getHealthChecks(command.loadBalancer.region).then((healthChecks) => {
+        command.backingData.healthChecks = healthChecks;
+        command.backingData.healthChecksKeyedByName = _.keyBy(healthChecks, 'name');
+        command.backingData.healthChecksKeyedByNameCopy = _.cloneDeep(command.backingData.healthChecksKeyedByName);
+
+        command.loadBalancer.healthChecks = command.loadBalancer.healthChecks.map((hc) => {
+          const updated = command.backingData.healthChecksKeyedByName[_.get(hc, 'name')];
+          if (updated) {
+            return _.cloneDeep(updated);
+          } else {
+            return hc;
+          }
+        });
+      });
+    }
+
+    function onCertificateRefresh(command) {
+      getCertificates().then((certificates) => {
+        command.backingData.certificates = certificates;
+      });
+    }
+
+    function onBackendServiceRefresh(command) {
+      getBackendServices(command.loadBalancer.region).then((backendServices) => {
+        command.backingData.backendServices = backendServices;
+        command.backingData.backendServicesKeyedByName = _.keyBy(backendServices, 'name');
+        command.backingData.backendServicesKeyedByNameCopy = _.cloneDeep(
+          command.backingData.backendServicesKeyedByName,
+        );
+
+        command.loadBalancer.backendServices = command.loadBalancer.backendServices.map((service) => {
+          const updated = command.backingData.backendServicesKeyedByName[_.get(service, 'name')];
+          if (updated) {
+            return _.cloneDeep(updated);
+          } else {
+            return service;
+          }
+        });
+      });
+    }
+
+    function onRegionSelected(command) {
+      buildBackingData(command.loadBalancer.region).then((backingData) => {
+        Object.assign(command.backingData, backingData);
+        unifyDataSources(command.backingData, command.loadBalancer);
+      });
+    }
+
+    function onHealthCheckSelected(selectedName, command) {
+      if (!command.loadBalancer.healthChecks.find((hc) => _.get(hc, 'name') === selectedName)) {
+        const selectedObject = command.backingData.healthChecksKeyedByName[selectedName];
+        if (selectedObject) {
+          command.loadBalancer.healthChecks.push(selectedObject);
+        }
+      }
+    }
+
+    function onBackendServiceSelected(selectedName, command) {
+      if (!command.loadBalancer.backendServices.find((service) => service.name === selectedName)) {
+        const selectedObject = command.backingData.backendServicesKeyedByName[selectedName];
+        command.loadBalancer.backendServices.push(selectedObject);
+        if (selectedObject.healthCheck) {
+          onHealthCheckSelected(selectedObject.healthCheck, command);
+        }
+      }
+    }
+
+    function getAllBackendServices(command) {
+      const allBackendServices = command.loadBalancer.backendServices.concat(command.backingData.backendServices);
+      return _.chain(allBackendServices)
+        .filter((service) => {
+          return (
+            service.account === command.loadBalancer.credentials || service.account === command.loadBalancer.account
+          );
+        })
+        .map('name')
+        .compact()
+        .uniq()
+        .value();
+    }
+
+    function getUnusedHealthChecks(command) {
+      return _.chain(command.loadBalancer.healthChecks)
+        .map('name')
+        .difference(_.map(command.loadBalancer.backendServices, 'healthCheck'))
+        .compact()
+        .uniq()
+        .value();
+    }
+
+    function getUnusedBackendServices(command) {
+      const defaultService = command.loadBalancer.defaultService;
+      const hostRuleServices = _.map(command.loadBalancer.hostRules, 'pathMatcher.defaultService');
+      const pathRuleServices = _.chain(command.loadBalancer.hostRules)
+        .map('pathMatcher.pathRules')
+        .flatten()
+        .map('backendService')
+        .value();
+
+      const usedServices = _.chain([defaultService, ...hostRuleServices, ...pathRuleServices])
+        .compact()
+        .uniq()
+        .value();
+
+      return _.chain(command.loadBalancer.backendServices)
+        .map('name')
+        .difference(usedServices)
+        .compact()
+        .uniq()
+        .value();
+    }
+
+    function removeUnusedBackendServices(command) {
+      const unusedBackendServices = getUnusedBackendServices(command);
+      command.loadBalancer.backendServices = command.loadBalancer.backendServices.filter(
+        (service) => !unusedBackendServices.includes(service.name),
+      );
+    }
+
+    function removeUnusedHealthChecks(command) {
+      const unusedHealthChecks = getUnusedHealthChecks(command);
+      command.loadBalancer.healthChecks = command.loadBalancer.healthChecks.filter(
+        (healthCheck) => !unusedHealthChecks.includes(healthCheck.name),
+      );
+    }
+
+    function onAccountChange(command) {
+      command.loadBalancer.backendServices = [];
+      command.loadBalancer.healthChecks = [];
+      command.loadBalancer.hostRules = [];
+      command.loadBalancer.listeners = [new ListenerTemplate()];
+      command.loadBalancer.defaultService = null;
+      command.backingData.regions = command.backingData.accounts
+        .find((account) => account.name === command.loadBalancer.credentials)
+        .regions.map((region) => region.name);
+    }
+
+    function onAddressRefresh(command) {
+      gceAddressReader.listAddresses('global').then((addresses) => {
+        command.backingData.addresses = addresses;
+      });
+    }
+
+    return { buildCommand };
+  },
+]);