@spinnaker/azure 0.0.0-main-2

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

@@ -0,0 +1,256 @@
+'use strict';
+
+describe('azureServerGroupTransformer', function () {
+  var transformer;
+
+  beforeEach(window.module(require('./serverGroup.transformer').name));
+
+  beforeEach(function () {
+    window.inject(function (_azureServerGroupTransformer_) {
+      transformer = _azureServerGroupTransformer_;
+    });
+  });
+
+  describe('command transforms', function () {
+    it('sets name correctly with no stack or detail', function () {
+      var base = {
+        application: 'myApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(base);
+
+      expect(transformed.name).toBe('myApp');
+    });
+
+    it('it sets name correctly with only stack', function () {
+      var command = {
+        stack: 's1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(transformed.name).toBe('theApp-s1');
+    });
+
+    it('it sets name correctly with only detail', function () {
+      var command = {
+        freeFormDetails: 'd1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(transformed.name).toBe('theApp-d1');
+    });
+
+    it('it sets name correctly with both stack and detail', function () {
+      var command = {
+        stack: 's1',
+        freeFormDetails: 'd1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(transformed.name).toBe('theApp-s1-d1');
+    });
+
+    it('it sets the Advanced Settings correctly when provided', function () {
+      var command = {
+        stack: 's1',
+        freeFormDetails: 'd1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+        osConfig: {
+          customData: 'this is custom data',
+        },
+        customScriptsSettings: {
+          fileUris: 'file1',
+          commandToExecute: 'do_this',
+        },
+      };
+
+      var customScript = {
+        fileUris: ['file1'],
+        commandToExecute: 'do_this',
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+      expect(transformed.osConfig.customData).toBe('this is custom data');
+      expect(transformed.customScriptsSettings).toEqual(customScript);
+    });
+
+    it('it sets the Advanced Settings correctly when not provided', function () {
+      var command = {
+        stack: 's1',
+        freeFormDetails: 'd1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(transformed.customScriptsSettings).toBeDefined();
+      expect(transformed.customScriptsSettings.fileUris).toBeNull();
+      expect(transformed.customScriptsSettings.commandToExecute).toBe('');
+    });
+
+    it('it sets the zones information', function () {
+      var command = {
+        zonesEnabled: true,
+        zones: ['1', '3'],
+        stack: 's1',
+        freeFormDetails: 'd1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(transformed.zonesEnabled).toEqual(true);
+      expect(transformed.zones).toEqual(command.zones);
+    });
+
+    it('it should not set the zones information if zonesEnabled is false', function () {
+      var command = {
+        zonesEnabled: false,
+        zones: ['1', '3'],
+        stack: 's1',
+        freeFormDetails: 'd1',
+        application: 'theApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+
+      expect(transformed.zonesEnabled).toEqual(false);
+      expect(transformed.zones).toEqual([]);
+    });
+
+    it('sets instance tags correctly when provided', function () {
+      let imap = new Map();
+      var base = {
+        application: 'myApp',
+        sku: {
+          capacity: 1,
+        },
+        selectedImage: {
+          publisher: 'Microsoft',
+          offer: 'Windows',
+          sku: 'Server2016',
+          version: '12.0.0.1',
+        },
+        selectedVnet: {},
+        viewState: {
+          mode: 'create',
+        },
+        instanceTags: imap,
+      };
+
+      var transformed = transformer.convertServerGroupCommandToDeployConfiguration(base);
+
+      expect(transformed.instanceTags).toBe(imap);
+    });
+  });
+});

package/src/subnet/subnetSelectField.directive.html

@@ -0,0 +1,28 @@
+<div class="form-group">
+  <div class="col-md-{{labelColumns}} sm-label-right">
+    VPC Subnet
+    <help-field key="{{helpKey}}"></help-field>
+  </div>
+  <div class="col-md-7" ng-if="!region">(Select an account)</div>
+  <div class="col-md-7" ng-if="region">
+    <select class="form-control input-sm" ng-model="component[field]" ng-change="onChange()" ng-if="!readOnly">
+      <option value="">None (EC2 Classic)</option>
+      <option
+        ng-repeat="subnet in activeSubnets | orderBy: 'label'"
+        value="{{subnet.purpose}}"
+        ng-selected="component[field] === subnet.purpose"
+      >
+        {{subnet.label}}
+      </option>
+      <option ng-if="activeSubnets.length && deprecatedSubnets.length" disabled>---------------</option>
+      <option
+        ng-repeat="subnet in deprecatedSubnets | orderBy: 'label'"
+        value="{{subnet.purpose}}"
+        ng-selected="component[field] === subnet.purpose"
+      >
+        {{subnet.label}}
+      </option>
+    </select>
+    <p ng-if="readOnly" class="form-control-static">{{component[field]}}</p>
+  </div>
+</div>

package/src/subnet/subnetSelectField.directive.js

@@ -0,0 +1,35 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const AZURE_SUBNET_SUBNETSELECTFIELD_DIRECTIVE = 'spinnaker.azure.subnet.subnetSelectField.directive';
+export const name = AZURE_SUBNET_SUBNETSELECTFIELD_DIRECTIVE; // for backwards compatibility
+module(AZURE_SUBNET_SUBNETSELECTFIELD_DIRECTIVE, []).directive('azureSubnetSelectField', function () {
+  return {
+    restrict: 'E',
+    templateUrl: require('./subnetSelectField.directive.html'),
+    scope: {
+      subnets: '=',
+      component: '=',
+      field: '@',
+      region: '=',
+      onChange: '&',
+      labelColumns: '@',
+      helpKey: '@',
+      readOnly: '=',
+    },
+    link: function (scope) {
+      function setSubnets() {
+        const subnets = scope.subnets || [];
+        scope.activeSubnets = subnets.filter(function (subnet) {
+          return !subnet.deprecated;
+        });
+        scope.deprecatedSubnets = subnets.filter(function (subnet) {
+          return subnet.deprecated;
+        });
+      }
+
+      scope.$watch('subnets', setSubnets);
+    },
+  };
+});

package/src/utility.spec.ts

@@ -0,0 +1,61 @@
+import type { ITagResult } from './utility';
+import Utility, { TagError } from './utility';
+
+describe('Azure Utility', function () {
+  it('returns tag error when null object passed', function () {
+    const tags: any = null;
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeFalsy();
+    expect(result.error).toBe(TagError.TAG_OBJECT_UNDEFINED);
+  });
+
+  it('returns tag error when number of tags exceeds limitation', function () {
+    const tags: any = {};
+    for (let i = 0; i < 13; i++) {
+      tags[`key${i}`] = `value${i}`;
+    }
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeFalsy();
+    expect(result.error).toBe(TagError.TAG_NUMBER_EXCEED);
+  });
+
+  it('returns tag error when length of key exceeds limitation', function () {
+    const tags: any = {};
+    tags['abcd'.repeat(128 + 1)] = '1';
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeFalsy();
+    expect(result.error).toBe(TagError.TAG_KEY_LENGTH_EXCEED);
+  });
+
+  it('returns tag error when length of value exceeds limitation', function () {
+    const tags: any = {};
+    tags['abcd'] = 'abcd'.repeat(64 + 1);
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeFalsy();
+    expect(result.error).toBe(TagError.TAG_VALUE_LENGTH_EXCEED);
+  });
+
+  it('returns tag error when key contains invalid character', function () {
+    const tags: any = {};
+    tags['abc&def'] = '1';
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeFalsy();
+    expect(result.error).toBe(TagError.TAG_KEY_INVALID_CHARACTER);
+  });
+
+  it('returns tag error when value contains invalid character', function () {
+    const tags: any = {};
+    tags['abcd'] = 'abc?def';
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeFalsy();
+    expect(result.error).toBe(TagError.TAG_VALUE_INVALID_CHARACTER);
+  });
+
+  it('returns no error when value are valid', function () {
+    const tags: any = {};
+    tags['abcd'] = 'abcdef';
+    const result: ITagResult = Utility.checkTags(tags);
+    expect(result.isValid).toBeTruthy();
+    expect(result.error).toBeNull();
+  });
+});

package/src/utility.ts

@@ -0,0 +1,95 @@
+export interface ITagResult {
+  isValid: boolean;
+  error: TagError | null;
+  errorMessage?: string;
+}
+
+export enum TagError {
+  TAG_NUMBER_EXCEED,
+  TAG_KEY_LENGTH_EXCEED,
+  TAG_VALUE_LENGTH_EXCEED,
+  TAG_KEY_INVALID_CHARACTER,
+  TAG_VALUE_INVALID_CHARACTER,
+  TAG_OBJECT_UNDEFINED,
+}
+
+export interface IAzureLoadBalancer {
+  type: string;
+  description: string;
+}
+
+export const AzureLoadBalancerTypes: IAzureLoadBalancer[] = [
+  {
+    type: 'Azure Load Balancer',
+    description: '',
+  },
+  {
+    type: 'Azure Application Gateway',
+    description: '',
+  },
+];
+
+export default class Utility {
+  public static readonly TAG_LIMITATION: number = 8;
+  public static readonly TAG_KEY_LENGTH_LIMITATION: number = 512;
+  public static readonly TAG_VALUE_LENGTH_LIMITATION: number = 256;
+  public static readonly TAG_INVALID_CHAR_REG_EXR: RegExp = /[<>%&\\?/]/;
+
+  public static checkTags(tagsObject: { [s: string]: string }): ITagResult {
+    if (!tagsObject) {
+      return {
+        isValid: false,
+        error: TagError.TAG_OBJECT_UNDEFINED,
+        errorMessage: 'instanceTags is not defined',
+      };
+    }
+    const length: number = Object.keys(tagsObject).length;
+    if (!(length >= 0 && length <= Utility.TAG_LIMITATION)) {
+      return {
+        isValid: false,
+        error: TagError.TAG_NUMBER_EXCEED,
+        errorMessage: `Number of tags exceeds the limit: ${Utility.TAG_LIMITATION}`,
+      };
+    }
+
+    for (const [k, v] of Object.entries(tagsObject)) {
+      if (k.length > Utility.TAG_KEY_LENGTH_LIMITATION) {
+        return {
+          isValid: false,
+          error: TagError.TAG_KEY_LENGTH_EXCEED,
+          errorMessage: `Length of Tag key: ${k} exceeds the limit: ${Utility.TAG_KEY_LENGTH_LIMITATION}`,
+        };
+      }
+      if (v.length > Utility.TAG_VALUE_LENGTH_LIMITATION) {
+        return {
+          isValid: false,
+          error: TagError.TAG_VALUE_LENGTH_EXCEED,
+          errorMessage: `Length of Tag value: ${v} exceeds the limit: ${Utility.TAG_VALUE_LENGTH_LIMITATION}`,
+        };
+      }
+      if (Utility.TAG_INVALID_CHAR_REG_EXR.test(k)) {
+        return {
+          isValid: false,
+          error: TagError.TAG_KEY_INVALID_CHARACTER,
+          errorMessage: `Invalid characters in Tag key: ${k}`,
+        };
+      }
+      if (Utility.TAG_INVALID_CHAR_REG_EXR.test(v)) {
+        return {
+          isValid: false,
+          error: TagError.TAG_VALUE_INVALID_CHARACTER,
+          errorMessage: `Invalid characters in Tag value: ${v}`,
+        };
+      }
+    }
+    return {
+      isValid: true,
+      error: null,
+    };
+  }
+
+  public static getLoadBalancerType(typeString: string): IAzureLoadBalancer | null {
+    typeString = typeString.toLowerCase().split('_').join(' ');
+    return AzureLoadBalancerTypes.find((lb: IAzureLoadBalancer) => lb.type.toLowerCase() === typeString) || null;
+  }
+}

package/src/validation/applicationName.validator.js

@@ -0,0 +1,44 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { ApplicationNameValidator } from '@spinnaker/core';
+
+export const AZURE_VALIDATION_APPLICATIONNAME_VALIDATOR = 'spinnaker.azure.validation.applicationName';
+export const name = AZURE_VALIDATION_APPLICATIONNAME_VALIDATOR; // for backwards compatibility
+module(AZURE_VALIDATION_APPLICATIONNAME_VALIDATOR, [])
+  .factory('azureApplicationNameValidator', 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 validate(name) {
+      const warnings = [];
+      const errors = [];
+
+      if (name && name.length) {
+        validateSpecialCharacters(name, errors);
+      }
+
+      return {
+        warnings: warnings,
+        errors: errors,
+      };
+    }
+
+    return {
+      validate: validate,
+    };
+  })
+  .run([
+    'azureApplicationNameValidator',
+    function (azureApplicationNameValidator) {
+      ApplicationNameValidator.registerValidator('azure', azureApplicationNameValidator);
+    },
+  ]);