@spinnaker/google 0.0.0-2025.1-0

package/src/loadBalancer/configure/internal/createLoadBalancerProperties.html

@@ -0,0 +1,98 @@
+<div class="container-fluid form-horizontal">
+  <ng-form name="locationForm">
+    <div class="modal-body">
+      <div class="form-group">
+        <div
+          class="col-md-12 well"
+          ng-class="{'alert-danger': locationForm.loadBalancerName.$error.validateUnique, 'alert-info': !locationForm.loadBalancerName.$error.validateUnique}"
+        >
+          <strong>Your load balancer will be named:</strong>
+          <span>{{ctrl.getName(ctrl.loadBalancer, ctrl.application)}}</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.loadBalancerName"
+            validate-unique="ctrl.existingLoadBalancerNames"
+            validate-ignore-case="true"
+            name="loadBalancerName"
+          />
+          <validation-error
+            ng-if="locationForm.loadBalancerName.$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.accountUpdated()"
+          ></account-select-field>
+        </div>
+      </div>
+      <gce-region-select-field
+        label-columns="2"
+        field-columns="8"
+        component="ctrl.loadBalancer"
+        field="region"
+        account="ctrl.loadBalancer.credentials"
+        on-change="ctrl.regionUpdated()"
+        regions="ctrl.regions"
+      ></gce-region-select-field>
+
+      <gce-network-select-field
+        networks="ctrl.networkOptions"
+        component="ctrl.loadBalancer"
+        on-change="ctrl.networkUpdated()"
+        field="network"
+        account="ctrl.loadBalancer.credentials"
+        field-columns="8"
+        label-columns="2"
+      ></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()"
+            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()"
+            ng-pattern="/^[a-z0-9-]*$/"
+          />
+        </div>
+        <div class="col-md-7 col-md-offset-3" ng-if="locationForm.stackName.$error.pattern">
+          <validation-error message="Stack can only contain letters and numbers."></validation-error>
+        </div>
+        <div class="col-md-7 col-md-offset-3" ng-if="locationForm.detailName.$error.pattern">
+          <validation-error message="Detail can only contain letters, numbers, and dashes(-)."></validation-error>
+        </div>
+      </div>
+      <div class="form-group">
+        <div class="col-md-9 col-md-offset-3" ng-if="locationForm.loadBalancerName.$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/internal/gceCreateInternalLoadBalancer.controller.ts

@@ -0,0 +1,276 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController, IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalInstanceService } from 'angular-ui-bootstrap';
+import _ from 'lodash';
+
+import type { Application, IAccount, ICredentials, IRegion } from '@spinnaker/core';
+import { AccountService, LoadBalancerWriter, TaskMonitor } from '@spinnaker/core';
+
+import { CommonGceLoadBalancerCtrl } from '../common/commonLoadBalancer.controller';
+import type { GceCommonLoadBalancerCommandBuilder } from '../common/commonLoadBalancerCommandBuilder.service';
+import { GCE_COMMON_LOAD_BALANCER_COMMAND_BUILDER } from '../common/commonLoadBalancerCommandBuilder.service';
+import { GCE_HEALTH_CHECK_SELECTOR_COMPONENT } from '../common/healthCheck.component';
+import { GOOGLE_COMMON_XPNNAMING_GCE_SERVICE } from '../../../common/xpnNaming.gce.service';
+import type {
+  IGceBackendService,
+  IGceHealthCheck,
+  IGceLoadBalancer,
+  IGceNetwork,
+  IGceSubnet,
+} from '../../../domain/index';
+import { GCEProviderSettings } from '../../../gce.settings';
+
+class ViewState {
+  constructor(public sessionAffinity: string) {}
+}
+
+interface IListKeyedByAccount {
+  [account: string]: string[];
+}
+
+interface IPrivateScope extends IScope {
+  $$destroyed: boolean;
+}
+
+class InternalLoadBalancer implements IGceLoadBalancer {
+  public name: string;
+  public stack: string;
+  public detail: string;
+  public loadBalancerName: string;
+  public ports: any;
+  public ipProtocol = 'TCP';
+  public loadBalancerType = 'INTERNAL';
+  public credentials: string;
+  public account: string;
+  public project: string;
+  public network = 'default';
+  public subnet: string;
+  public cloudProvider = 'gce';
+  public backendService: IGceBackendService = { healthCheck: { healthCheckType: 'TCP' } } as IGceBackendService;
+
+  constructor(public region: string) {}
+}
+
+class InternalLoadBalancerCtrl extends CommonGceLoadBalancerCtrl implements IController {
+  public pages: any = {
+    location: require('./createLoadBalancerProperties.html'),
+    listener: require('./listener.html'),
+    healthCheck: require('../common/commonHealthCheckPage.html'),
+    advancedSettings: require('../common/commonAdvancedSettingsPage.html'),
+  };
+  public sessionAffinityViewToModelMap: any = {
+    None: 'NONE',
+    'Client IP': 'CLIENT_IP',
+    'Client IP and protocol': 'CLIENT_IP_PROTO',
+    'Client IP, port and protocol': 'CLIENT_IP_PORT_PROTO',
+  };
+  public accounts: ICredentials[];
+  public regions: string[];
+  public networks: IGceNetwork[];
+  public networkOptions: string[];
+  public subnets: IGceSubnet[];
+  public subnetOptions: string[];
+  public healthChecksByAccountAndType: { [account: string]: { [healthCheckType: string]: IGceHealthCheck[] } };
+
+  // The 'by account' maps populate the corresponding 'existing names' lists below.
+  public existingLoadBalancerNamesByAccount: IListKeyedByAccount;
+  public existingHealthCheckNamesByAccount: IListKeyedByAccount;
+  public existingLoadBalancerNames: string[];
+  public existingHealthCheckNames: string[];
+
+  public viewState: ViewState = new ViewState('None');
+  public taskMonitor: any;
+
+  private sessionAffinityModelToViewMap: any = _.invert(this.sessionAffinityViewToModelMap);
+
+  public static $inject = [
+    '$scope',
+    'application',
+    '$uibModalInstance',
+    'loadBalancer',
+    'gceCommonLoadBalancerCommandBuilder',
+    'isNew',
+    'wizardSubFormValidation',
+    'gceXpnNamingService',
+    '$state',
+  ];
+  constructor(
+    public $scope: IPrivateScope,
+    public application: Application,
+    public $uibModalInstance: IModalInstanceService,
+    private loadBalancer: InternalLoadBalancer,
+    private gceCommonLoadBalancerCommandBuilder: GceCommonLoadBalancerCommandBuilder,
+    private isNew: boolean,
+    private wizardSubFormValidation: any,
+    private gceXpnNamingService: any,
+    $state: StateService,
+  ) {
+    super($scope, application, $uibModalInstance, $state);
+  }
+
+  public $onInit(): void {
+    this.gceCommonLoadBalancerCommandBuilder
+      .getBackingData(['existingLoadBalancerNamesByAccount', 'accounts', 'networks', 'subnets', 'healthChecks'])
+      .then((backingData) => {
+        if (!this.isNew) {
+          this.initializeEditMode();
+        } else {
+          this.loadBalancer = new InternalLoadBalancer(
+            GCEProviderSettings ? GCEProviderSettings.defaults.region : null,
+          );
+        }
+
+        this.loadBalancer.loadBalancerName = this.getName(this.loadBalancer, this.application);
+
+        const accountNames: string[] = backingData.accounts.map((account: IAccount) => account.name);
+        if (accountNames.length && !accountNames.includes(this.loadBalancer.account)) {
+          this.loadBalancer.credentials = accountNames[0];
+        } else {
+          this.loadBalancer.credentials = this.loadBalancer.account;
+        }
+
+        this.accounts = backingData.accounts;
+        this.networks = backingData.networks;
+        this.subnets = backingData.subnets;
+        this.existingLoadBalancerNamesByAccount = backingData.existingLoadBalancerNamesByAccount;
+        this.healthChecksByAccountAndType = this.gceCommonLoadBalancerCommandBuilder.groupHealthChecksByAccountAndType(
+          backingData.healthChecks as IGceHealthCheck[],
+        );
+
+        // We don't count the load balancer's health check in the existing health checks list.
+        const healthCheckNamesToOmit = this.isNew ? [] : [this.loadBalancer.backendService.healthCheck.name];
+        this.existingHealthCheckNamesByAccount = this.gceCommonLoadBalancerCommandBuilder.groupHealthCheckNamesByAccount(
+          backingData.healthChecks as IGceHealthCheck[],
+          healthCheckNamesToOmit,
+        );
+
+        this.accountUpdated();
+
+        this.wizardSubFormValidation
+          .config({ scope: this.$scope, form: 'form' })
+          .register({ page: 'location', subForm: 'locationForm' })
+          .register({ page: 'listener', subForm: 'listenerForm' })
+          .register({ page: 'healthCheck', subForm: 'healthCheckForm' })
+          .register({ page: 'advancedSettings', subForm: 'advancedSettingsForm' });
+
+        this.taskMonitor = new TaskMonitor({
+          application: this.application,
+          title: (this.isNew ? 'Creating ' : 'Updating ') + 'your load balancer',
+          modalInstance: this.$uibModalInstance,
+          onTaskComplete: () => this.onTaskComplete(this.loadBalancer),
+        });
+      });
+  }
+
+  public onHealthCheckRefresh(): void {
+    this.gceCommonLoadBalancerCommandBuilder.getBackingData(['healthChecks']).then((data) => {
+      this.healthChecksByAccountAndType = this.gceCommonLoadBalancerCommandBuilder.groupHealthChecksByAccountAndType(
+        data.healthChecks as IGceHealthCheck[],
+      );
+
+      const healthCheckNamesToOmit = this.isNew ? [] : [this.loadBalancer.backendService.healthCheck.name];
+      this.existingHealthCheckNamesByAccount = this.gceCommonLoadBalancerCommandBuilder.groupHealthCheckNamesByAccount(
+        data.healthChecks as IGceHealthCheck[],
+        healthCheckNamesToOmit,
+      );
+    });
+  }
+
+  public networkUpdated(): void {
+    this.subnetOptions = this.subnets
+      .filter((subnet) => {
+        return (
+          subnet.region === this.loadBalancer.region &&
+          (subnet.account === this.loadBalancer.credentials || subnet.account === this.loadBalancer.account) &&
+          subnet.network === this.loadBalancer.network
+        );
+      })
+      .map((subnet) => subnet.id);
+
+    if (!this.subnetOptions.includes(this.loadBalancer.subnet)) {
+      this.loadBalancer.subnet = this.subnetOptions[0];
+    }
+  }
+
+  public protocolUpdated(): void {
+    if (this.loadBalancer.ipProtocol === 'UDP') {
+      this.viewState = new ViewState('None');
+      this.loadBalancer.backendService.sessionAffinity = 'NONE';
+    }
+  }
+
+  public accountUpdated(): void {
+    const existingHealthCheckNames = _.get<any, string[]>(this, [
+      'existingHealthCheckNamesByAccount',
+      this.loadBalancer.credentials,
+    ]);
+    this.existingHealthCheckNames = existingHealthCheckNames || [];
+
+    const existingLoadBalancerNames = _.get<any, string[]>(this, [
+      'existingLoadBalancerNamesByAccount',
+      this.loadBalancer.credentials,
+    ]);
+    this.existingLoadBalancerNames = existingLoadBalancerNames || [];
+
+    this.networkOptions = this.networks
+      .filter((network: IGceNetwork) => network.account === this.loadBalancer.credentials)
+      .map((network) => network.id);
+
+    AccountService.getRegionsForAccount(this.loadBalancer.credentials).then((regions: IRegion[]) => {
+      this.regions = regions.map((region: IRegion) => region.name);
+      this.networkUpdated();
+    });
+  }
+
+  public regionUpdated(): void {
+    this.networkUpdated();
+  }
+
+  public updateName(): void {
+    this.loadBalancer.loadBalancerName = this.getName(this.loadBalancer, this.application);
+  }
+
+  public setSessionAffinity(viewState: ViewState): void {
+    this.loadBalancer.backendService.sessionAffinity = this.sessionAffinityViewToModelMap[viewState.sessionAffinity];
+  }
+
+  public submit(): void {
+    const descriptor = this.isNew ? 'Create' : 'Update';
+    const toSubmitLoadBalancer = _.cloneDeep(this.loadBalancer) as any;
+    toSubmitLoadBalancer.ports = toSubmitLoadBalancer.ports.split(',').map((port: string) => port.trim());
+    toSubmitLoadBalancer.cloudProvider = 'gce';
+    toSubmitLoadBalancer.name = toSubmitLoadBalancer.loadBalancerName;
+    toSubmitLoadBalancer.backendService.name = toSubmitLoadBalancer.loadBalancerName;
+    delete toSubmitLoadBalancer.instances;
+
+    this.taskMonitor.submit(() =>
+      LoadBalancerWriter.upsertLoadBalancer(toSubmitLoadBalancer, this.application, descriptor, {
+        healthCheck: {},
+      }),
+    );
+  }
+
+  private initializeEditMode(): void {
+    this.loadBalancer.ports = this.loadBalancer.ports.join(', ');
+    this.loadBalancer.subnet = this.gceXpnNamingService.decorateXpnResourceIfNecessary(
+      this.loadBalancer.project,
+      this.loadBalancer.subnet,
+    );
+    this.loadBalancer.network = this.gceXpnNamingService.decorateXpnResourceIfNecessary(
+      this.loadBalancer.project,
+      this.loadBalancer.network,
+    );
+    this.viewState = new ViewState(
+      this.sessionAffinityModelToViewMap[this.loadBalancer.backendService.sessionAffinity],
+    );
+  }
+}
+
+export const GCE_INTERNAL_LOAD_BALANCER_CTRL = 'spinnaker.gce.internalLoadBalancer.controller';
+
+module(GCE_INTERNAL_LOAD_BALANCER_CTRL, [
+  GCE_HEALTH_CHECK_SELECTOR_COMPONENT,
+  GCE_COMMON_LOAD_BALANCER_COMMAND_BUILDER,
+  GOOGLE_COMMON_XPNNAMING_GCE_SERVICE,
+]).controller('gceInternalLoadBalancerCtrl', InternalLoadBalancerCtrl);

package/src/loadBalancer/configure/internal/listener.html

@@ -0,0 +1,41 @@
+<div class="container-fluid form-horizontal">
+  <ng-form name="listenerForm">
+    <div class="form-group">
+      <div class="col-md-12">
+        <table class="table table-condensed packed">
+          <thead>
+            <tr>
+              <th>Protocol</th>
+              <th>Subnet</th>
+              <th>Ports<help-field key="gce.internalLoadBalancer.ports"></help-field></th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>
+                <select
+                  ng-disabled="!ctrl.isNew"
+                  class="form-control input-sm"
+                  ng-change="ctrl.protocolUpdated()"
+                  ng-model="ctrl.loadBalancer.ipProtocol"
+                  ng-options="protocol for protocol in ['TCP', 'UDP']"
+                ></select>
+              </td>
+
+              <td>
+                <select
+                  class="form-control input-sm"
+                  ng-options="subnet for subnet in ctrl.subnetOptions"
+                  ng-disabled="!ctrl.isNew"
+                  ng-model="ctrl.loadBalancer.subnet"
+                ></select>
+              </td>
+
+              <td><input class="form-control input-sm" required ng-model="ctrl.loadBalancer.ports" /></td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+  </ng-form>
+</div>

package/src/loadBalancer/configure/internalhttp/createInternalHttpLoadBalancer.controller.ts

@@ -0,0 +1,173 @@
+import type { StateService } from '@uirouter/angularjs';
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import type { IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalInstanceService } from 'angular-ui-bootstrap';
+
+import type { Application } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+
+import { GCE_CACHE_REFRESH } from '../../../cache/cacheRefresh.component';
+import { GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT } from '../../details/hostAndPathRules/hostAndPathRulesButton.component';
+import type { IGceHttpLoadBalancer } from '../../../domain';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BACKENDSERVICE_BACKENDSERVICE_COMPONENT } from '../http/backendService/backendService.component';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BASICSETTINGS_BASICSETTINGS_COMPONENT } from '../http/basicSettings/basicSettings.component';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_COMMANDBUILDER_SERVICE } from '../http/commandBuilder.service';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HEALTHCHECK_HEALTHCHECK_COMPONENT } from '../http/healthCheck/healthCheck.component';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HOSTRULE_HOSTRULE_COMPONENT } from '../http/hostRule/hostRule.component';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE } from '../http/httpLoadBalancer.write.service';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_LISTENERS_LISTENER_COMPONENT } from '../http/listeners/listener.component';
+import { BackendServiceTemplate, HealthCheckTemplate, HostRuleTemplate, ListenerTemplate } from '../http/templates';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE } from '../http/transformer.service';
+
+import '../http/httpLoadBalancerWizard.component.less';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_INTERNAL_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER =
+  'spinnaker.deck.gce.loadBalancer.createInternalHttp.controller';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_INTERNAL_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER; // for backwards compatibility
+
+class CreateInternalHttpLoadBalancerController implements ng.IComponentController {
+  public taskMonitor: any;
+  public command: any;
+  public modalDescriptor: string;
+
+  public pages = {
+    location: require('../http/basicSettings/basicSettings.html'),
+    listeners: require('../http/listeners/listeners.html'),
+    defaultService: require('../http/defaultService/defaultService.html'),
+    backendServices: require('../http/backendService/backendServices.html'),
+    healthChecks: require('../http/healthCheck/healthChecks.html'),
+    hostRules: require('../http/hostRule/hostRules.html'),
+  };
+
+  private keyToTemplateMap: { [key: string]: any } = {
+    backendServices: BackendServiceTemplate,
+    healthChecks: HealthCheckTemplate,
+    hostRules: HostRuleTemplate,
+    listeners: ListenerTemplate,
+  };
+
+  public static $inject = [
+    '$scope',
+    'application',
+    '$uibModalInstance',
+    'loadBalancer',
+    'gceHttpLoadBalancerCommandBuilder',
+    'isNew',
+    'wizardSubFormValidation',
+    'gceHttpLoadBalancerTransformer',
+    'gceHttpLoadBalancerWriter',
+    '$state',
+  ];
+
+  constructor(
+    public $scope: IScope,
+    public application: Application,
+    public $uibModalInstance: IModalInstanceService,
+    private loadBalancer: IGceHttpLoadBalancer,
+    private gceHttpLoadBalancerCommandBuilder: any,
+    private isNew: boolean,
+    private wizardSubFormValidation: any,
+    private gceHttpLoadBalancerTransformer: any,
+    private gceHttpLoadBalancerWriter: any,
+    private $state: StateService,
+  ) {
+    this.modalDescriptor = this.isNew
+      ? 'Create Internal HTTP(S) load balancer'
+      : `Edit ${this.loadBalancer.name}:${this.loadBalancer.region}:${this.loadBalancer.account}`;
+
+    const onTaskComplete = () => {
+      application.loadBalancers.refresh();
+      application.loadBalancers.onNextRefresh($scope, this.onApplicationRefresh.bind(this));
+    };
+
+    $scope.taskMonitor = this.taskMonitor = new TaskMonitor({
+      application: this.application,
+      title: (this.isNew ? 'Creating ' : 'Updating ') + 'your load balancer',
+      modalInstance: this.$uibModalInstance,
+      onTaskComplete: onTaskComplete,
+    });
+  }
+
+  public $onInit(): void {
+    this.gceHttpLoadBalancerCommandBuilder
+      .buildCommand({ isNew: this.isNew, originalLoadBalancer: this.loadBalancer, isInternal: true })
+      .then((command: any) => {
+        this.command = command;
+        this.wizardSubFormValidation
+          .config({ scope: this.$scope, form: 'form' })
+          .register({ page: 'location', subForm: 'location' })
+          .register({
+            page: 'listeners',
+            subForm: 'listeners',
+            validators: [
+              {
+                watchString: 'ctrl.command.loadBalancer.listeners',
+                validator: (listeners: any[]) => listeners.length > 0,
+                collection: true,
+              },
+            ],
+          })
+          .register({ page: 'default-service', subForm: 'defaultService' })
+          .register({ page: 'health-checks', subForm: 'healthChecks' })
+          .register({ page: 'backend-services', subForm: 'backendServices' })
+          .register({ page: 'host-rules', subForm: 'hostRules' });
+      });
+  }
+
+  public add(key: string): void {
+    this.command.loadBalancer[key].push(new this.keyToTemplateMap[key]());
+  }
+
+  public remove(key: string, index: number): void {
+    this.command.loadBalancer[key].splice(index, 1);
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public submit(): void {
+    const serializedCommands = this.gceHttpLoadBalancerTransformer.serialize(this.command, this.loadBalancer);
+    const descriptor = this.isNew ? 'Create' : 'Update';
+    this.taskMonitor.submit(() =>
+      this.gceHttpLoadBalancerWriter.upsertLoadBalancers(serializedCommands, this.application, descriptor),
+    );
+  }
+
+  private onApplicationRefresh(): void {
+    // If the user has already closed the modal, do not navigate to the new details view
+    if (this.$scope.$$destroyed) {
+      return;
+    }
+    this.$uibModalInstance.close();
+    const lb = this.command.loadBalancer;
+    const newStateParams = {
+      name: lb.urlMapName,
+      accountId: lb.credentials,
+      region: lb.region,
+      provider: 'gce',
+    };
+
+    if (!this.$state.includes('**.loadBalancerDetails')) {
+      this.$state.go('.loadBalancerDetails', newStateParams);
+    } else {
+      this.$state.go('^.loadBalancerDetails', newStateParams);
+    }
+  }
+}
+
+module(GOOGLE_LOADBALANCER_CONFIGURE_INTERNAL_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER, [
+  'ui.bootstrap',
+  UIROUTER_ANGULARJS,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BACKENDSERVICE_BACKENDSERVICE_COMPONENT,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_BASICSETTINGS_BASICSETTINGS_COMPONENT,
+  GCE_CACHE_REFRESH,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_COMMANDBUILDER_SERVICE,
+  GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HEALTHCHECK_HEALTHCHECK_COMPONENT,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HOSTRULE_HOSTRULE_COMPONENT,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_LISTENERS_LISTENER_COMPONENT,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE,
+]).controller('gceCreateInternalHttpLoadBalancerCtrl', CreateInternalHttpLoadBalancerController);

package/src/loadBalancer/configure/network/advancedSettings.html

@@ -0,0 +1,54 @@
+<div class="form-group">
+  <div class="col-md-8 nest">
+    <div class="form-group">
+      <div class="col-md-6 sm-label-right">
+        <b>Timeout</b><help-field key="loadBalancer.advancedSettings.healthTimeout"></help-field>
+      </div>
+      <div class="col-md-4">
+        <input class="form-control input-sm" type="number" min="0" ng-model="loadBalancer.healthTimeout" />
+      </div>
+    </div>
+
+    <div class="form-group">
+      <div class="col-md-6 sm-label-right">
+        <b>Interval</b><help-field key="gce.loadBalancer.advancedSettings.healthInterval"></help-field>
+      </div>
+      <div class="col-md-4">
+        <input class="form-control input-sm" type="number" min="0" ng-model="loadBalancer.healthInterval" />
+      </div>
+    </div>
+
+    <div class="form-group">
+      <div class="col-md-6 sm-label-right">
+        <b>Healthy Threshold</b><help-field key="gce.loadBalancer.advancedSettings.healthyThreshold"></help-field>
+      </div>
+      <div class="col-md-4">
+        <input class="form-control input-sm" type="number" min="0" ng-model="loadBalancer.healthyThreshold" />
+      </div>
+    </div>
+
+    <div class="form-group">
+      <div class="col-md-6 sm-label-right">
+        <b>Unhealthy Threshold</b><help-field key="gce.loadBalancer.advancedSettings.unhealthyThreshold"></help-field>
+      </div>
+      <div class="col-md-4">
+        <input class="form-control input-sm" type="number" min="0" ng-model="loadBalancer.unhealthyThreshold" />
+      </div>
+    </div>
+
+    <div class="form-group">
+      <div class="col-md-6 sm-label-right">
+        <b>Session Affinity</b><help-field key="gce.loadBalancer.advancedSettings.unhealthyThreshold"></help-field>
+      </div>
+      <div class="col-md-4">
+        <select
+          class="form-control input-sm"
+          ng-model="loadBalancer.sessionAffinity"
+          ng-options="option.value as option.name for option in sessionAffinityOptions"
+          ng-disabled="!isNew"
+          name="sessionAffinitySelect"
+        ></select>
+      </div>
+    </div>
+  </div>
+</div>