@spinnaker/google 0.0.0-2025.1-0

package/src/serverGroup/serverGroup.transformer.spec.js

@@ -0,0 +1,59 @@
+'use strict';
+
+describe('gceServerGroupTransformer', () => {
+  let transformer, $q, $scope;
+  beforeEach(window.module(require('./serverGroup.transformer').name));
+
+  beforeEach(() => {
+    window.inject((_$q_, $rootScope, _gceServerGroupTransformer_) => {
+      $q = _$q_;
+      $scope = $rootScope.$new();
+      transformer = _gceServerGroupTransformer_;
+    });
+  });
+
+  describe('normalize server group load balancers', () => {
+    let app;
+    beforeEach(() => {
+      app = {
+        getDataSource: () => {
+          return {
+            ready: () => $q.resolve(),
+            data: [
+              { name: 'network-load-balancer', account: 'my-google-account' },
+              { name: 'internal-load-balancer', account: 'my-google-account' },
+              {
+                name: 'url-map-name',
+                provider: 'gce',
+                account: 'my-google-account',
+                region: 'global',
+                loadBalancerType: 'HTTP',
+                listeners: [{ name: 'http-load-balancer-listener' }, { name: 'https-load-balancer-listener' }],
+              },
+            ],
+          };
+        },
+      };
+    });
+
+    it('should map listener names to url map names', function () {
+      const serverGroup = {
+        account: 'my-google-account',
+        loadBalancers: [
+          'network-load-balancer',
+          'internal-load-balancer',
+          'http-load-balancer-listener',
+          'https-load-balancer-listener',
+        ],
+      };
+
+      let normalizedServerGroup;
+      transformer.normalizeServerGroup(serverGroup, app).then((normalized) => (normalizedServerGroup = normalized));
+      $scope.$digest();
+      expect(normalizedServerGroup.loadBalancers.length).toBe(3);
+      expect(normalizedServerGroup.loadBalancers.includes('url-map-name')).toEqual(true);
+      expect(normalizedServerGroup.loadBalancers.includes('network-load-balancer')).toEqual(true);
+      expect(normalizedServerGroup.loadBalancers.includes('internal-load-balancer')).toEqual(true);
+    });
+  });
+});

package/src/subnet/subnet.renderer.js

@@ -0,0 +1,34 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { NetworkReader } from '@spinnaker/core';
+
+export const GOOGLE_SUBNET_SUBNET_RENDERER = 'spinnaker.gce.subnet.renderer';
+export const name = GOOGLE_SUBNET_SUBNET_RENDERER; // for backwards compatibility
+module(GOOGLE_SUBNET_SUBNET_RENDERER, []).factory('gceSubnetRenderer', function () {
+  let gceNetworks;
+
+  NetworkReader.listNetworksByProvider('gce').then(function (networks) {
+    gceNetworks = networks;
+  });
+
+  function render(serverGroup) {
+    if (serverGroup.subnet) {
+      return serverGroup.subnet;
+    } else {
+      const autoCreateSubnets = _.chain(gceNetworks)
+        .filter({ account: serverGroup.account, name: serverGroup.network })
+        .map('autoCreateSubnets')
+        .head()
+        .value();
+
+      return autoCreateSubnets ? '(Auto-select)' : '[none]';
+    }
+  }
+
+  return {
+    render: render,
+  };
+});

package/src/subnet/subnetSelectField.directive.html

@@ -0,0 +1,21 @@
+<div class="form-group">
+  <div class="col-md-{{labelColumns}} sm-label-right">
+    Subnet
+    <help-field key="{{helpKey}}"></help-field>
+  </div>
+  <div class="col-md-{{fieldColumns || 7}}" ng-if="subnetPlaceholder">{{subnetPlaceholder}}</div>
+  <div class="col-md-{{fieldColumns || 7}}" ng-if="!subnetPlaceholder">
+    <select
+      class="form-control input-sm"
+      ng-if="account"
+      ng-model="component.subnet"
+      ng-change="onChange()"
+      ng-required="autoCreateSubnets === false"
+    >
+      <option ng-repeat="subnet in subnets" value="{{subnet}}" ng-selected="component[field] === subnet">
+        {{subnet}}
+      </option>
+    </select>
+    <p ng-if="readOnly" class="form-control-static">{{component[field]}}</p>
+  </div>
+</div>

package/src/subnet/subnetSelectField.directive.js

@@ -0,0 +1,24 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const GOOGLE_SUBNET_SUBNETSELECTFIELD_DIRECTIVE = 'spinnaker.google.subnet.subnetSelectField.directive';
+export const name = GOOGLE_SUBNET_SUBNETSELECTFIELD_DIRECTIVE; // for backwards compatibility
+module(GOOGLE_SUBNET_SUBNETSELECTFIELD_DIRECTIVE, []).directive('gceSubnetSelectField', function () {
+  return {
+    restrict: 'E',
+    templateUrl: require('./subnetSelectField.directive.html'),
+    scope: {
+      subnets: '=',
+      subnetPlaceholder: '=',
+      autoCreateSubnets: '=',
+      component: '=',
+      field: '@',
+      account: '=',
+      region: '=',
+      onChange: '&',
+      labelColumns: '@',
+      helpKey: '@',
+    },
+  };
+});

package/src/validation/applicationName.validator.js

@@ -0,0 +1,114 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { ApplicationNameValidator, FirewallLabels } from '@spinnaker/core';
+
+export const GOOGLE_VALIDATION_APPLICATIONNAME_VALIDATOR = 'spinnaker.gce.validation.applicationName';
+export const name = GOOGLE_VALIDATION_APPLICATIONNAME_VALIDATOR; // for backwards compatibility
+module(GOOGLE_VALIDATION_APPLICATIONNAME_VALIDATOR, [])
+  .factory('gceApplicationNameValidator', function () {
+    function validateSpecialCharacters(name, errors) {
+      const pattern = /^([a-zA-Z][a-zA-Z0-9]*)?$/;
+      if (!pattern.test(name)) {
+        errors.push(
+          'The application name must begin with a letter and must contain only letters or digits. No ' +
+            'special characters are allowed.',
+        );
+      }
+    }
+
+    function validateLength(name, warnings, errors) {
+      // GCE resource names must comply with https://www.ietf.org/rfc/rfc1035.txt
+      // [a-z]([-a-z0-9]*[a-z0-9])?
+      const maxResourceNameLength = 63;
+
+      // e.g. $appName-$stack-$detail-tp-1451531076528 and $appName-$stack-$detail-hc-1451531076528
+      const loadBalancerNameSuffixLength = 17;
+      const maxLengthForLoadBalancers = maxResourceNameLength - loadBalancerNameSuffixLength;
+
+      // e.g. $appName-$stack-$detail-v000-abcd
+      const instanceNameSuffixLength = 10;
+      const maxLengthForServerGroups = maxResourceNameLength - instanceNameSuffixLength;
+
+      if (name.length > maxResourceNameLength) {
+        errors.push('The maximum length for an application in Google is 63 characters.');
+        return;
+      }
+
+      if (name.length > maxLengthForLoadBalancers - 12) {
+        if (name.length > maxLengthForLoadBalancers) {
+          warnings.push(`You will not be able to create a Google load balancer for this application if the
+            application's name is longer than ${maxLengthForLoadBalancers} characters (currently: ${name.length}
+          characters).`);
+        } else if (name.length >= maxLengthForLoadBalancers - 2) {
+          warnings.push(
+            'With separators ("-"), you will not be able to include a stack and detail field for ' +
+              'Google load balancers.',
+          );
+        } else {
+          const remaining = maxLengthForLoadBalancers - 2 - name.length;
+          warnings.push(`If you plan to include a stack or detail field for Google load balancers, you will only
+            have ~${remaining} characters to do so.`);
+        }
+      }
+
+      if (name.length > maxLengthForServerGroups - 12) {
+        if (name.length > maxLengthForServerGroups) {
+          warnings.push(`You will not be able to create a Google server group for this application if the
+            application's name is longer than ${maxLengthForServerGroups} characters (currently: ${name.length}
+            characters).`);
+        } else if (name.length >= maxLengthForServerGroups - 2) {
+          warnings.push(
+            'With separators ("-"), you will not be able to include a stack and detail field for ' +
+              'Google server groups.',
+          );
+        } else {
+          const remaining = maxLengthForServerGroups - 2 - name.length;
+          warnings.push(`If you plan to include a stack or detail field for Google server groups, you will only
+            have ~${remaining} characters to do so.`);
+        }
+      }
+
+      if (name.length > maxResourceNameLength - 12) {
+        if (name.length >= maxResourceNameLength - 2) {
+          warnings.push(
+            `With separators ("-"), you will not be able to include a stack and detail field for Google ${FirewallLabels.get(
+              'firewalls',
+            )}.`,
+          );
+        } else {
+          const remaining = maxResourceNameLength - 2 - name.length;
+          warnings.push(`If you plan to include a stack or detail field for Google ${FirewallLabels.get(
+            'firewalls',
+          )}, you will only
+            have ~${remaining} characters to do so.`);
+        }
+      }
+    }
+
+    function validate(name) {
+      const warnings = [];
+      const errors = [];
+
+      if (name && name.length) {
+        validateSpecialCharacters(name, errors);
+        validateLength(name, warnings, errors);
+      }
+
+      return {
+        warnings: warnings,
+        errors: errors,
+      };
+    }
+
+    return {
+      validate: validate,
+    };
+  })
+  .run([
+    'gceApplicationNameValidator',
+    function (gceApplicationNameValidator) {
+      ApplicationNameValidator.registerValidator('gce', gceApplicationNameValidator);
+    },
+  ]);