@spinnaker/google 2026.2.2 → 2026.3.0

package/src/loadBalancer/configure/tcp/gceCreateTcpLoadBalancer.controller.ts

@@ -1,234 +0,0 @@
-import type { StateService } from '@uirouter/angularjs';
-import type { IScope } from 'angular';
-import { module } from 'angular';
-import type { IModalInstanceService } from 'angular-ui-bootstrap';
-import _ from 'lodash';
-
-import type {
-  Application,
-  IAccount,
-  ICredentials,
-  IInstance,
-  ILoadBalancerUpsertCommand,
-  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 type { IGceBackendService, IGceHealthCheck, IGceLoadBalancer } from '../../../domain/index';
-import { GCEProviderSettings } from '../../../gce.settings';
-
-class ViewState {
-  constructor(public sessionAffinity: string) {}
-}
-
-interface IListKeyedByAccount {
-  [account: string]: string[];
-}
-
-interface ITcpLoadBalancerUpsertDescription extends ILoadBalancerUpsertCommand {
-  backendService: IGceBackendService;
-  loadBalancerName: string;
-  instances: IInstance[];
-}
-
-class TcpLoadBalancer implements IGceLoadBalancer {
-  public stack: string;
-  public detail: string;
-  public loadBalancerName: string;
-  public portRange = '443';
-  public ipProtocol = 'TCP';
-  public instances: IInstance[];
-  public loadBalancerType = 'TCP';
-  public credentials: string;
-  public account: string;
-  public backendService: IGceBackendService = { healthCheck: { healthCheckType: 'TCP' } } as IGceBackendService;
-  public cloudProvider: string;
-  public name: string;
-  constructor(public region = 'global') {}
-}
-
-class TcpLoadBalancerCtrl extends CommonGceLoadBalancerCtrl implements ng.IComponentController {
-  public pages: any = {
-    location: require('./createLoadBalancerProperties.html'),
-    listener: require('./listener.html'),
-    healthCheck: require('../common/commonHealthCheckPage.html'),
-    advancedSettings: require('../common/commonAdvancedSettingsPage.html'),
-    backendService: require('./backendService.html'),
-  };
-  public sessionAffinityViewToModelMap: any = {
-    None: 'NONE',
-    'Client IP': 'CLIENT_IP',
-    'Generated Cookie': 'GENERATED_COOKIE',
-  };
-  public accounts: ICredentials[];
-  public regions: string[];
-  public healthChecksByAccountAndType: { [account: string]: { [healthCheckType: string]: IGceHealthCheck[] } };
-  public portOptions: string[] = ['25', '43', '110', '143', '195', '443', '465', '587', '700', '993', '995'];
-
-  // 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 maxCookieTtl = 60 * 60 * 24; // One day.
-  public taskMonitor: any;
-  public hasBackendService = true;
-
-  private sessionAffinityModelToViewMap: any = _.invert(this.sessionAffinityViewToModelMap);
-
-  public static $inject = [
-    '$scope',
-    'application',
-    '$uibModalInstance',
-    'loadBalancer',
-    'gceCommonLoadBalancerCommandBuilder',
-    'isNew',
-    'forPipelineConfig',
-    'wizardSubFormValidation',
-    '$state',
-  ];
-  constructor(
-    public $scope: IScope,
-    public application: Application,
-    public $uibModalInstance: IModalInstanceService,
-    private loadBalancer: TcpLoadBalancer,
-    private gceCommonLoadBalancerCommandBuilder: GceCommonLoadBalancerCommandBuilder,
-    private isNew: boolean,
-    private forPipelineConfig: boolean,
-    private wizardSubFormValidation: any,
-    $state: StateService,
-  ) {
-    super($scope, application, $uibModalInstance, $state);
-  }
-
-  public $onInit(): void {
-    this.gceCommonLoadBalancerCommandBuilder
-      .getBackingData(['existingLoadBalancerNamesByAccount', 'accounts', 'healthChecks'])
-      .then((backingData) => {
-        if (!this.isNew) {
-          this.initializeEditMode();
-        } else {
-          this.loadBalancer = new TcpLoadBalancer(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.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 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 || [];
-
-    AccountService.getRegionsForAccount(this.loadBalancer.credentials).then((regions: IRegion[]) => {
-      this.regions = regions.map((region: IRegion) => region.name);
-    });
-  }
-
-  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 ITcpLoadBalancerUpsertDescription;
-    toSubmitLoadBalancer.name = toSubmitLoadBalancer.loadBalancerName;
-    toSubmitLoadBalancer.backendService.name = toSubmitLoadBalancer.loadBalancerName;
-    toSubmitLoadBalancer.cloudProvider = 'gce';
-    delete toSubmitLoadBalancer.instances;
-
-    if (this.forPipelineConfig) {
-      Object.assign(toSubmitLoadBalancer, { healthCheck: {} });
-      this.$uibModalInstance.close(toSubmitLoadBalancer);
-      return;
-    }
-
-    this.taskMonitor.submit(() =>
-      LoadBalancerWriter.upsertLoadBalancer(toSubmitLoadBalancer, this.application, descriptor, {
-        healthCheck: {},
-      }),
-    );
-  }
-
-  private initializeEditMode(): void {
-    this.loadBalancer.portRange = this.loadBalancer.portRange.split('-')[0];
-    this.viewState = new ViewState(
-      this.sessionAffinityModelToViewMap[this.loadBalancer.backendService.sessionAffinity],
-    );
-  }
-}
-
-export const GCE_TCP_LOAD_BALANCER_CTRL = 'spinnaker.gce.tcpLoadBalancer.controller';
-
-module(GCE_TCP_LOAD_BALANCER_CTRL, [
-  GCE_HEALTH_CHECK_SELECTOR_COMPONENT,
-  GCE_COMMON_LOAD_BALANCER_COMMAND_BUILDER,
-]).controller('gceTcpLoadBalancerCtrl', TcpLoadBalancerCtrl);

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

@@ -1,15 +0,0 @@
-<div class="container-fluid form-horizontal">
-  <ng-form name="listenerForm">
-    <div class="form-group">
-      <div class="col-md-4 sm-label-right">Port</div>
-      <div class="col-md-4">
-        <select
-          class="form-control input-sm"
-          ng-options="port for port in ctrl.portOptions"
-          ng-disabled="!ctrl.isNew"
-          ng-model="ctrl.loadBalancer.portRange"
-        ></select>
-      </div>
-    </div>
-  </ng-form>
-</div>

package/src/loadBalancer/details/backendService/backendService.component.ts

@@ -1,23 +0,0 @@
-import { module } from 'angular';
-
-const gceBackendServiceDetailsComponent: ng.IComponentOptions = {
-  bindings: {
-    backendService: '<',
-  },
-  template: `
-    <dt>Name</dt>
-    <dd>{{$ctrl.backendService.name}}</dd>
-    <dt>Health Check</dt>
-    <dd>{{$ctrl.backendService.healthCheck.name}}</dd>
-    <dt ng-if="$ctrl.backendService.sessionAffinity">Session Affinity</dt>
-    <dd ng-if="$ctrl.backendService.sessionAffinity">{{$ctrl.backendService.sessionAffinity | gceSessionAffinityFilter}}</dd>
-    <dt ng-if="$ctrl.backendService.sessionAffinity === 'GENERATED_COOKIE'">Affinity Cookie TTL</dt>
-    <dd ng-if="$ctrl.backendService.sessionAffinity === 'GENERATED_COOKIE'">{{$ctrl.backendService.affinityCookieTtlSec}}</dd>`,
-};
-
-export const GCE_BACKEND_SERVICE_DETAILS_COMPONENT =
-  'spinnaker.gce.loadBalancer.details.backendServiceDetails.component';
-module(GCE_BACKEND_SERVICE_DETAILS_COMPONENT, []).component(
-  'gceBackendServiceDetails',
-  gceBackendServiceDetailsComponent,
-);

package/src/loadBalancer/details/backendService/sessionAffinity.filter.ts

@@ -1,11 +0,0 @@
-import { module } from 'angular';
-import { sessionAffinityModelToViewMap } from '../../configure/common/sessionAffinityNameMaps';
-
-function gceSessionAffinityFilter() {
-  return function (modelValue: string): string {
-    return sessionAffinityModelToViewMap[modelValue] || modelValue;
-  };
-}
-
-export const SESSION_AFFINITY_FILTER = 'spinnaker.gce.loadBalancer.details.sessionAffinity.filter';
-module(SESSION_AFFINITY_FILTER, []).filter('gceSessionAffinityFilter', gceSessionAffinityFilter);

package/src/loadBalancer/details/deleteModal/deleteModal.controller.ts

@@ -1,105 +0,0 @@
-import type { IController } from 'angular';
-import { module } from 'angular';
-import type { IModalInstanceService } from 'angular-ui-bootstrap';
-import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
-
-import type { Application, ILoadBalancerDeleteCommand } from '@spinnaker/core';
-import { LoadBalancerWriter, TaskMonitor } from '@spinnaker/core';
-
-import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE } from '../../configure/http/httpLoadBalancer.write.service';
-import type { GceHttpLoadBalancerUtils } from '../../httpLoadBalancerUtils.service';
-import { GCE_HTTP_LOAD_BALANCER_UTILS } from '../../httpLoadBalancerUtils.service';
-
-class Verification {
-  public verified = false;
-}
-
-class Params {
-  public deleteHealthChecks = false;
-}
-
-interface IGoogleLoadBalancerDeleteOperation extends ILoadBalancerDeleteCommand {
-  region: string;
-  accountName: string;
-  deleteHealthChecks: boolean;
-  loadBalancerType: string;
-}
-
-class DeleteLoadBalancerModalController implements IController {
-  public verification: Verification = new Verification();
-  public params: Params = new Params();
-  public taskMonitor: any;
-
-  public static $inject = [
-    'application',
-    'gceHttpLoadBalancerUtils',
-    'gceHttpLoadBalancerWriter',
-    'loadBalancer',
-    '$uibModalInstance',
-  ];
-  constructor(
-    private application: Application,
-    private gceHttpLoadBalancerUtils: GceHttpLoadBalancerUtils,
-    private gceHttpLoadBalancerWriter: any,
-    private loadBalancer: any,
-    private $uibModalInstance: IModalInstanceService,
-  ) {}
-
-  public $onInit(): void {
-    const taskMonitorConfig = {
-      application: this.application,
-      title: 'Deleting ' + this.loadBalancer.name,
-      modalInstance: this.$uibModalInstance,
-    };
-
-    this.taskMonitor = new TaskMonitor(taskMonitorConfig);
-  }
-
-  public isValid(): boolean {
-    return this.verification.verified;
-  }
-
-  public submit(): void {
-    this.taskMonitor.submit(this.getSubmitMethod());
-  }
-
-  public cancel(): void {
-    this.$uibModalInstance.dismiss();
-  }
-
-  public hasHealthChecks(): boolean {
-    if (this.gceHttpLoadBalancerUtils.isHttpLoadBalancer(this.loadBalancer)) {
-      return true;
-    } else {
-      return !!this.loadBalancer.healthCheck;
-    }
-  }
-
-  private getSubmitMethod(): () => PromiseLike<any> {
-    if (this.gceHttpLoadBalancerUtils.isHttpLoadBalancer(this.loadBalancer)) {
-      return () => {
-        return this.gceHttpLoadBalancerWriter.deleteLoadBalancers(this.loadBalancer, this.application, this.params);
-      };
-    } else {
-      return () => {
-        const command: IGoogleLoadBalancerDeleteOperation = {
-          cloudProvider: 'gce',
-          loadBalancerName: this.loadBalancer.name,
-          accountName: this.loadBalancer.account,
-          credentials: this.loadBalancer.account,
-          region: this.loadBalancer.region,
-          loadBalancerType: this.loadBalancer.loadBalancerType || 'NETWORK',
-          deleteHealthChecks: this.params.deleteHealthChecks,
-        };
-        return LoadBalancerWriter.deleteLoadBalancer(command, this.application);
-      };
-    }
-  }
-}
-
-export const DELETE_MODAL_CONTROLLER = 'spinnaker.gce.loadBalancer.deleteModal.controller';
-module(DELETE_MODAL_CONTROLLER, [
-  ANGULAR_UI_BOOTSTRAP as any,
-  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE,
-  GCE_HTTP_LOAD_BALANCER_UTILS,
-]).controller('gceLoadBalancerDeleteModalCtrl', DeleteLoadBalancerModalController);

package/src/loadBalancer/details/deleteModal/deleteModal.html

@@ -1,31 +0,0 @@
-<div modal-page class="confirmation-modal">
-  <task-monitor monitor="ctrl.taskMonitor"></task-monitor>
-  <form role="form" ng-if="!ctrl.submitting">
-    <modal-close dismiss="$dismiss()"></modal-close>
-    <div class="modal-header">
-      <h4 class="modal-title">Really delete {{ctrl.loadBalancer.name}}?</h4>
-    </div>
-    <div class="modal-body confirmation-modal" ng-if="ctrl.hasHealthChecks()">
-      <div class="row">
-        <div class="col-md-offset-2 col-md-8" style="padding-left: 2px">
-          <div class="checkbox">
-            <label> <input ng-model="ctrl.params.deleteHealthChecks" type="checkbox" />Delete health checks? </label>
-            <help-field
-              expand="true"
-              content="If the health checks associated with this load balancer
-                                 are being used by other resources, they will not be deleted,
-                                 whether this option is selected or not."
-            ></help-field>
-          </div>
-        </div>
-      </div>
-    </div>
-    <gce-footer
-      action="ctrl.submit()"
-      cancel="ctrl.cancel()"
-      is-valid="ctrl.isValid()"
-      account="ctrl.loadBalancer.account"
-      verification="ctrl.verification"
-    ></gce-footer>
-  </form>
-</div>

package/src/loadBalancer/details/healthCheck/healthCheck.component.html

@@ -1,14 +0,0 @@
-<dt>Name</dt>
-<dd>{{ $ctrl.healthCheck.name }}</dd>
-<dt ng-if="$ctrl.healthCheck.healthCheckType">Type</dt>
-<dd ng-if="$ctrl.healthCheck.healthCheckType">{{ $ctrl.healthCheck.healthCheckType }}</dd>
-<dt ng-if="$ctrl.healthCheck.target">Target</dt>
-<dd ng-if="$ctrl.healthCheck.target">{{ $ctrl.healthCheck.target }}</dd>
-<dt>Timeout</dt>
-<dd>{{ $ctrl.healthCheck.timeout || $ctrl.healthCheck.timeoutSec }} seconds</dd>
-<dt>Interval</dt>
-<dd>{{ $ctrl.healthCheck.interval || $ctrl.healthCheck.checkIntervalSec }} seconds</dd>
-<dt>Healthy Threshold</dt>
-<dd>{{ $ctrl.healthCheck.healthyThreshold }}</dd>
-<dt>Unhealthy Threshold</dt>
-<dd>{{ $ctrl.healthCheck.unhealthyThreshold }}</dd>

package/src/loadBalancer/details/healthCheck/healthCheck.component.js

@@ -1,13 +0,0 @@
-'use strict';
-
-import { module } from 'angular';
-
-export const GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT =
-  'spinnaker.deck.gce.loadBalancer.details.healthCheck.component';
-export const name = GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_DETAILS_HEALTHCHECK_HEALTHCHECK_COMPONENT, []).component('gceHealthCheck', {
-  bindings: {
-    healthCheck: '=',
-  },
-  templateUrl: require('./healthCheck.component.html'),
-});

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRules.controller.js

@@ -1,23 +0,0 @@
-import { module } from 'angular';
-
-import { GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE } from './hostAndPathRules.service';
-
-('use strict');
-
-export const GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER =
-  'spinnaker.deck.gce.loadBalancer.hostAndPathRules.controller';
-export const name = GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER, [
-  GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE,
-]).controller('gceHostAndPathRulesCtrl', [
-  'hostRules',
-  'defaultService',
-  'loadBalancerName',
-  '$uibModalInstance',
-  'hostAndPathRulesService',
-  function (hostRules, defaultService, loadBalancerName, $uibModalInstance, hostAndPathRulesService) {
-    this.table = hostAndPathRulesService.buildTable(hostRules, defaultService);
-    this.loadBalancerName = loadBalancerName;
-    this.close = $uibModalInstance.dismiss;
-  },
-]);

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRules.modal.html

@@ -1,40 +0,0 @@
-<div modal-page class="form-inline">
-  <modal-close dismiss="$dismiss()"></modal-close>
-  <div class="modal-header">
-    <h4 class="modal-title">Host And Path Rules for {{ ctrl.loadBalancerName }}</h4>
-  </div>
-  <div class="modal-body clearfix">
-    <div class="section-body">
-      <div class="well well-sm">
-        <div class="row">
-          <div class="col-md-12 content-fields">
-            <input placeholder="Filter" ng-model="searchText" class="form-control input-sm" />
-          </div>
-        </div>
-        <div class="row">
-          <div class="col-md-12">
-            <table class="table table-condensed">
-              <thead>
-                <tr>
-                  <th>Host</th>
-                  <th>Path</th>
-                  <th>Backend Service</th>
-                </tr>
-              </thead>
-              <tbody>
-                <tr ng-repeat="row in ctrl.table | filter:searchText">
-                  <td>{{ row.hostPattern }}</td>
-                  <td>{{ row.path }}</td>
-                  <td>{{ row.backend }}</td>
-                </tr>
-              </tbody>
-            </table>
-          </div>
-        </div>
-      </div>
-    </div>
-  </div>
-  <div class="modal-footer">
-    <button class="btn btn-default" ng-click="ctrl.close()">Close</button>
-  </div>
-</div>

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRules.service.js

@@ -1,41 +0,0 @@
-'use strict';
-
-import { module } from 'angular';
-
-export const GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE =
-  'spinnaker.deck.gce.loadBalancer.hostAndPathRules.service';
-export const name = GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_SERVICE, []).factory(
-  'hostAndPathRulesService',
-  function () {
-    function buildTable(hostRules, defaultService) {
-      const defaultRow = buildRow('Any unmatched (default)', 'Any unmatched (default)', defaultService.name);
-      if (hostRules.length === 0) {
-        return [defaultRow];
-      }
-
-      return hostRules.reduce(
-        (rows, hostRule) => {
-          const [hostPattern] = hostRule.hostPatterns;
-          const { defaultService, pathRules } = hostRule.pathMatcher;
-
-          rows.push(buildRow(hostPattern, '/*', defaultService.name));
-
-          return rows.concat(
-            pathRules.reduce((rows, pathRule) => {
-              const { backendService, paths } = pathRule;
-              return rows.concat(paths.map((path) => buildRow(hostPattern, path, backendService.name)));
-            }, []),
-          );
-        },
-        [defaultRow],
-      );
-    }
-
-    function buildRow(hostPattern, path, backend) {
-      return { hostPattern, path, backend };
-    }
-
-    return { buildTable };
-  },
-);

package/src/loadBalancer/details/hostAndPathRules/hostAndPathRulesButton.component.js

@@ -1,39 +0,0 @@
-import { module } from 'angular';
-import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
-
-import { GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER } from './hostAndPathRules.controller';
-
-('use strict');
-
-export const GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT =
-  'spinnaker.deck.gce.loadBalancer.hostAndPathRulesButton.component';
-export const name = GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULESBUTTON_COMPONENT, [
-  ANGULAR_UI_BOOTSTRAP,
-  GOOGLE_LOADBALANCER_DETAILS_HOSTANDPATHRULES_HOSTANDPATHRULES_CONTROLLER,
-]).component('gceHostAndPathRulesButton', {
-  bindings: {
-    hostRules: '=',
-    defaultService: '=',
-    loadBalancerName: '=',
-  },
-  template: '<a href ng-click="$ctrl.viewHostAndPathRules()">View Host and Path Rules</a>',
-  controller: [
-    '$uibModal',
-    function ($uibModal) {
-      this.viewHostAndPathRules = () => {
-        $uibModal.open({
-          templateUrl: require('./hostAndPathRules.modal.html'),
-          controller: 'gceHostAndPathRulesCtrl',
-          controllerAs: 'ctrl',
-          size: 'lg',
-          resolve: {
-            hostRules: () => this.hostRules,
-            defaultService: () => this.defaultService,
-            loadBalancerName: () => this.loadBalancerName,
-          },
-        });
-      };
-    },
-  ],
-});