@spinnaker/google 2026.2.2 → 2026.3.0

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

@@ -1,191 +0,0 @@
-'use strict';
-
-import { module } from 'angular';
-import _ from 'lodash';
-
-import { NameUtils } from '@spinnaker/core';
-
-import { sessionAffinityModelToViewMap, sessionAffinityViewToModelMap } from '../common/sessionAffinityNameMaps';
-
-export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE = 'spinnaker.gce.deck.httpLoadBalancer.transformer';
-export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE, []).factory(
-  'gceHttpLoadBalancerTransformer',
-  function () {
-    // SERIALIZE
-
-    const keysToOmit = ['backendServices', 'healthChecks', 'listeners', 'stack', 'detail'];
-
-    function serialize(originalCommand, originalLoadBalancer) {
-      const command = _.cloneDeep(originalCommand);
-      const { loadBalancer, backingData } = command;
-
-      mapComponentNamesToObjects(loadBalancer, backingData);
-
-      loadBalancer.hostRules = loadBalancer.hostRules.reduce((hostRules, hostRule) => {
-        return hostRules.concat(
-          hostRule.hostPatterns.map((hostPattern) => {
-            return {
-              hostPatterns: [hostPattern],
-              pathMatcher: _.cloneDeep(hostRule.pathMatcher),
-            };
-          }),
-        );
-      }, []);
-
-      const commands = buildCommandForEachListener(loadBalancer);
-
-      if (originalLoadBalancer) {
-        commands[0].listenersToDelete = _.chain(originalLoadBalancer.listeners)
-          .map('name')
-          .difference(_.map(originalCommand.loadBalancer.listeners, 'name'))
-          .value();
-      }
-
-      return commands;
-    }
-
-    function mapComponentNamesToObjects(loadBalancer, backingData) {
-      const unifiedHealthChecksKeyedByName = _.assign(
-        backingData.healthChecksKeyedByName,
-        _.keyBy(loadBalancer.healthChecks, 'name'),
-      );
-      const unifiedBackendServicesKeyedByName = _.assign(
-        backingData.backendServicesKeyedByName,
-        _.keyBy(loadBalancer.backendServices, 'name'),
-      );
-
-      _.forEach(unifiedBackendServicesKeyedByName, (service) => {
-        service.healthCheck = unifiedHealthChecksKeyedByName[service.healthCheck];
-        // Map human readable text back to session affinity code.
-        service.sessionAffinity = sessionAffinityViewToModelMap[service.sessionAffinity] || service.sessionAffinity;
-      });
-
-      loadBalancer.defaultService = unifiedBackendServicesKeyedByName[loadBalancer.defaultService];
-      mapBackendServiceNamesToObjects(loadBalancer.hostRules, unifiedBackendServicesKeyedByName);
-    }
-
-    function mapBackendServiceNamesToObjects(hostRules, servicesByName) {
-      hostRules.forEach((hostRule) => {
-        const p = hostRule.pathMatcher;
-
-        p.defaultService = servicesByName[p.defaultService];
-
-        p.pathRules.forEach((pathRule) => {
-          pathRule.backendService = servicesByName[pathRule.backendService];
-        });
-      });
-    }
-
-    function buildCommandForEachListener(loadBalancer) {
-      return loadBalancer.listeners.map((listener) => {
-        let command = _.cloneDeep(loadBalancer);
-        command = _.omit(command, keysToOmit);
-        // Determine the authoritative cert source. The certificateSource field is explicit when
-        // present, but listeners deserialized from LBs created before this field existed may only
-        // have certificate/certificateMap values without a source. The fallback condition handles
-        // that: no certificate + truthy certificateMap implies certificateMap mode.
-        const useCertificateMap =
-          listener.certificateSource === 'certificateMap' || (!listener.certificate && !!listener.certificateMap);
-        command.name = listener.name;
-        command.portRange = listener.port;
-        command.certificate = useCertificateMap ? null : listener.certificate || null;
-        command.certificateMap = useCertificateMap ? listener.certificateMap || null : null;
-        command.ipAddress = listener.ipAddress;
-        command.subnet = listener.subnet;
-
-        return command;
-      });
-    }
-
-    // DESERIALIZE
-
-    function deserialize(loadBalancer) {
-      const { backendServices, healthChecks, defaultService } = getHealthChecksAndBackendServices(loadBalancer);
-      const hostRules = getHostRules(loadBalancer);
-      const listeners = getListeners(loadBalancer);
-
-      return {
-        defaultService: defaultService.name,
-        backendServices,
-        healthChecks,
-        hostRules,
-        listeners,
-        network: loadBalancer.network,
-        region: loadBalancer.region,
-        urlMapName: loadBalancer.urlMapName,
-        credentials: loadBalancer.credentials || loadBalancer.account,
-      };
-    }
-
-    function getHealthChecksAndBackendServices(loadBalancer) {
-      const defaultService = loadBalancer.defaultService;
-      let backendServices = [loadBalancer.defaultService];
-
-      if (loadBalancer.hostRules) {
-        backendServices = loadBalancer.hostRules.reduce((services, hostRule) => {
-          services = services.concat(hostRule.pathMatcher.defaultService);
-          return hostRule.pathMatcher.pathRules.reduce(
-            (services, pathRule) => services.concat(pathRule.backendService),
-            services,
-          );
-        }, backendServices);
-      }
-
-      const healthChecks = _.chain(backendServices).map('healthCheck').uniqBy('name').cloneDeep().value();
-      healthChecks.forEach((hc) => {
-        hc.account = loadBalancer.account || loadBalancer.credentials;
-      });
-      backendServices = _.uniqBy(backendServices, 'name');
-
-      backendServices.forEach((service) => {
-        // Map health check to health check name so we don't have to deal with object references
-        service.healthCheck = service.healthCheck.name;
-        // Map session affinity code to more human readable text.
-        service.sessionAffinity = sessionAffinityModelToViewMap[service.sessionAffinity] || service.sessionAffinity;
-      });
-
-      return { backendServices, healthChecks, defaultService };
-    }
-
-    function getHostRules(loadBalancer) {
-      return mapBackendServicesToNames(_.cloneDeep(loadBalancer.hostRules));
-    }
-
-    function getListeners(loadBalancer) {
-      loadBalancer.listeners.forEach((listener) => {
-        const { stack, freeFormDetails } = NameUtils.parseLoadBalancerName(listener.name);
-        listener.stack = stack;
-        listener.detail = freeFormDetails;
-        listener.created = true;
-        listener.certificate = listener.certificate || null;
-        // Normalize certificateMap from the full Certificate Manager URL returned by the server
-        // (e.g. //certificatemanager.googleapis.com/projects/p/locations/global/certificateMaps/cm)
-        // to its short resource name. This mirrors getCertificateMapName in listener.component.js.
-        listener.certificateMap = listener.certificateMap ? _.last(listener.certificateMap.split('/')) : null;
-        // Infer certificateSource for listeners deserialized from LBs created before this field
-        // existed. The presence of certificateMap implies certificateMap mode.
-        listener.certificateSource = listener.certificateMap ? 'certificateMap' : 'certificate';
-      });
-
-      return loadBalancer.listeners;
-    }
-
-    function mapBackendServicesToNames(hostRules) {
-      // Map backend service to backend service name so we don't have to deal with object references
-      hostRules.forEach((hostRule) => {
-        const p = hostRule.pathMatcher;
-
-        p.defaultService = p.defaultService.name;
-
-        p.pathRules.forEach((pathRule) => {
-          pathRule.backendService = pathRule.backendService.name;
-        });
-      });
-
-      return hostRules;
-    }
-
-    return { serialize, deserialize };
-  },
-);

package/src/loadBalancer/configure/http/transformer.service.spec.js

@@ -1,182 +0,0 @@
-import { mock } from 'angular';
-
-describe('Service: gceHttpLoadBalancerTransformer', () => {
-  let gceHttpLoadBalancerTransformer;
-
-  beforeEach(mock.module(require('./transformer.service').name));
-
-  beforeEach(
-    mock.inject((_gceHttpLoadBalancerTransformer_) => {
-      gceHttpLoadBalancerTransformer = _gceHttpLoadBalancerTransformer_;
-    }),
-  );
-
-  function buildBaseCommand(listener) {
-    return {
-      loadBalancer: {
-        listeners: [listener],
-        hostRules: [],
-        backendServices: [],
-        healthChecks: [],
-        defaultService: 'default-service',
-      },
-      backingData: {
-        healthChecksKeyedByName: {
-          'hc-1': { name: 'hc-1' },
-        },
-        backendServicesKeyedByName: {
-          'default-service': {
-            name: 'default-service',
-            sessionAffinity: 'NONE',
-            healthCheck: 'hc-1',
-          },
-        },
-      },
-    };
-  }
-
-  it('serializes certificateMap listeners as certificateMap-only commands', () => {
-    const command = buildBaseCommand({
-      name: 'app-main',
-      port: 443,
-      certificate: null,
-      certificateMap: 'cm',
-      certificateSource: 'certificateMap',
-      ipAddress: '10.0.0.1',
-      subnet: null,
-    });
-
-    const commands = gceHttpLoadBalancerTransformer.serialize(command, null);
-
-    expect(commands.length).toBe(1);
-    expect(commands[0].certificate).toBeNull();
-    expect(commands[0].certificateMap).toBe('cm');
-  });
-
-  it('serializes legacy certificate listeners without certificateMap', () => {
-    const command = buildBaseCommand({
-      name: 'app-main',
-      port: 443,
-      certificate: 'legacy-cert',
-      certificateMap: 'cm',
-      certificateSource: 'certificate',
-      ipAddress: '10.0.0.1',
-      subnet: null,
-    });
-
-    const commands = gceHttpLoadBalancerTransformer.serialize(command, null);
-
-    expect(commands.length).toBe(1);
-    expect(commands[0].certificate).toBe('legacy-cert');
-    expect(commands[0].certificateMap).toBeNull();
-  });
-
-  it('deserializes certificateMap listeners with certificateMap mode', () => {
-    const loadBalancer = {
-      defaultService: {
-        name: 'default-service',
-        healthCheck: { name: 'hc-1' },
-        sessionAffinity: 'NONE',
-      },
-      hostRules: [],
-      listeners: [
-        {
-          name: 'app-main',
-          certificate: null,
-          certificateMap: '//certificatemanager.googleapis.com/projects/p/locations/global/certificateMaps/cm',
-        },
-      ],
-      network: 'default',
-      region: 'global',
-      urlMapName: 'app',
-      account: 'test-account',
-    };
-
-    const commandLoadBalancer = gceHttpLoadBalancerTransformer.deserialize(loadBalancer);
-
-    expect(commandLoadBalancer.listeners.length).toBe(1);
-    expect(commandLoadBalancer.listeners[0].certificateSource).toBe('certificateMap');
-    expect(commandLoadBalancer.listeners[0].certificate).toBeNull();
-    expect(commandLoadBalancer.listeners[0].certificateMap).toBe('cm');
-  });
-
-  // The serialize fallback path: when certificateSource is absent, the
-  // condition `!listener.certificate && !!listener.certificateMap` at line 89
-  // of transformer.service.js infers certificateMap mode. This covers LBs
-  // created before the certificateSource field existed.
-  it('serializes certificateMap listener without explicit certificateSource via fallback', () => {
-    const command = buildBaseCommand({
-      name: 'app-main',
-      port: 443,
-      certificate: null,
-      certificateMap: 'cm',
-      ipAddress: '10.0.0.1',
-      subnet: null,
-    });
-
-    const commands = gceHttpLoadBalancerTransformer.serialize(command, null);
-
-    expect(commands.length).toBe(1);
-    expect(commands[0].certificate).toBeNull();
-    expect(commands[0].certificateMap).toBe('cm');
-  });
-
-  it('deserializes cert-only listener and infers certificateSource as certificate', () => {
-    const loadBalancer = {
-      defaultService: {
-        name: 'default-service',
-        healthCheck: { name: 'hc-1' },
-        sessionAffinity: 'NONE',
-      },
-      hostRules: [],
-      listeners: [
-        {
-          name: 'app-main',
-          certificate: 'legacy-cert',
-          certificateMap: null,
-        },
-      ],
-      network: 'default',
-      region: 'global',
-      urlMapName: 'app',
-      account: 'test-account',
-    };
-
-    const commandLoadBalancer = gceHttpLoadBalancerTransformer.deserialize(loadBalancer);
-
-    expect(commandLoadBalancer.listeners.length).toBe(1);
-    expect(commandLoadBalancer.listeners[0].certificateSource).toBe('certificate');
-    expect(commandLoadBalancer.listeners[0].certificate).toBe('legacy-cert');
-    expect(commandLoadBalancer.listeners[0].certificateMap).toBeNull();
-  });
-
-  it('deserializes listener with neither cert nor map and defaults to certificate source', () => {
-    const loadBalancer = {
-      defaultService: {
-        name: 'default-service',
-        healthCheck: { name: 'hc-1' },
-        sessionAffinity: 'NONE',
-      },
-      hostRules: [],
-      listeners: [
-        {
-          name: 'app-main',
-          certificate: null,
-          certificateMap: null,
-        },
-      ],
-      network: 'default',
-      region: 'global',
-      urlMapName: 'app',
-      account: 'test-account',
-    };
-
-    const commandLoadBalancer = gceHttpLoadBalancerTransformer.deserialize(loadBalancer);
-
-    expect(commandLoadBalancer.listeners.length).toBe(1);
-    // With neither field set, certificateSource defaults to 'certificate' (HTTP mode).
-    expect(commandLoadBalancer.listeners[0].certificateSource).toBe('certificate');
-    expect(commandLoadBalancer.listeners[0].certificate).toBeNull();
-    expect(commandLoadBalancer.listeners[0].certificateMap).toBeNull();
-  });
-});

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

@@ -1,98 +0,0 @@
-<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>