@spinnaker/oracle 0.0.0-main-2

package/src/loadBalancer/configure/createLoadBalancer.controller.ts

@@ -0,0 +1,540 @@
+import type { StateService } from '@uirouter/angularjs';
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import type { IController } from 'angular';
+import { module } from 'angular';
+import type { IModalServiceInstance } from 'angular-ui-bootstrap';
+import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
+import { cloneDeep, trimEnd } from 'lodash';
+
+import type { Application, IAccountDetails, ILoadBalancer, INetwork, IRegion, ISubnet } from '@spinnaker/core';
+import {
+  AccountService,
+  LoadBalancerWriter,
+  NameUtils,
+  NetworkReader,
+  SubnetReader,
+  TaskMonitor,
+} from '@spinnaker/core';
+import type {
+  IOracleBackEndSet,
+  IOracleListener,
+  IOracleListenerCertificate,
+  IOracleLoadBalancer,
+  IOracleSubnet,
+} from '../../domain/IOracleLoadBalancer';
+import { LoadBalancingPolicy } from '../../domain/IOracleLoadBalancer';
+
+import type { OracleLoadBalancerTransformer } from '../loadBalancer.transformer';
+import { ORACLE_LOAD_BALANCER_TRANSFORMER } from '../loadBalancer.transformer';
+
+export class OracleLoadBalancerController implements IController {
+  public oracle = 'oracle';
+  public shapes: string[] = ['100Mbps', '400Mbps', '8000Mbps']; // TODO desagar use listShapes to get this from clouddriver later
+  public loadBalancingPolicies: string[] = Object.keys(LoadBalancingPolicy).map((k) => (LoadBalancingPolicy as any)[k]);
+  public pages: { [key: string]: any } = {
+    properties: require('./createLoadBalancerProperties.html'),
+    listeners: require('./listeners.html'),
+    backendSets: require('./backendSets.html'),
+    certificates: require('./certificates.html'),
+  };
+
+  public state: { [key: string]: boolean } = {
+    accountsLoaded: false,
+    submitting: false,
+  };
+
+  public allVnets: INetwork[];
+  public allSubnets: IOracleSubnet[];
+  public filteredVnets: INetwork[];
+  public filteredSubnets: ISubnet[];
+  public filteredSubnetsByType: ISubnet[];
+  public selectedVnet: INetwork;
+  public selectedSubnets: IOracleSubnet[];
+  public numSubnetsAllowed = 1;
+  public listeners: IOracleListener[] = [];
+  public backendSets: IOracleBackEndSet[] = [];
+  public certificates: IOracleListenerCertificate[] = [];
+
+  public static $inject = [
+    '$scope',
+    '$uibModalInstance',
+    '$state',
+    'oracleLoadBalancerTransformer',
+    'application',
+    'loadBalancer',
+    'isNew',
+  ];
+  constructor(
+    private $scope: ng.IScope,
+    private $uibModalInstance: IModalServiceInstance,
+    private $state: StateService,
+    private oracleLoadBalancerTransformer: OracleLoadBalancerTransformer,
+    private application: Application,
+    private loadBalancer: IOracleLoadBalancer,
+    private isNew: boolean,
+  ) {
+    this.initializeController();
+  }
+
+  public onApplicationRefresh() {
+    // 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 newStateParams = {
+      name: this.loadBalancer.name,
+      accountId: this.loadBalancer.account,
+      region: this.loadBalancer.region,
+      provider: 'oracle',
+    };
+
+    if (!this.$state.includes('**.loadBalancerDetails')) {
+      this.$state.go('.loadBalancerDetails', newStateParams);
+    } else {
+      this.$state.go('^.loadBalancerDetails', newStateParams);
+    }
+  }
+
+  public onTaskComplete() {
+    this.application.loadBalancers.refresh();
+    this.application.loadBalancers.onNextRefresh(this.$scope, this.onApplicationRefresh);
+  }
+
+  public initializeCreateMode() {
+    AccountService.listAccounts(this.oracle).then((accounts: IAccountDetails[]) => {
+      this.$scope.accounts = accounts; // TODO desagar does this need to be in $scope?
+      this.state.accountsLoaded = true;
+      this.$scope.state = this.state;
+      this.accountUpdated();
+    });
+    this.loadVnets();
+    this.loadSubnets();
+  }
+
+  private initControllerFromLoadBalancerCmd() {
+    this.numSubnetsAllowed = this.calcNumSubnetsAllowed();
+    if (this.$scope.loadBalancerCmd.listeners) {
+      Object.keys(this.$scope.loadBalancerCmd.listeners).forEach((lis) => {
+        this.listeners.push(this.$scope.loadBalancerCmd.listeners[lis]);
+      });
+    }
+    if (this.$scope.loadBalancerCmd.backendSets) {
+      Object.keys(this.$scope.loadBalancerCmd.backendSets).forEach((b) => {
+        this.backendSets.push(this.$scope.loadBalancerCmd.backendSets[b]);
+      });
+    }
+    if (this.$scope.loadBalancerCmd.certificates) {
+      Object.keys(this.$scope.loadBalancerCmd.certificates).forEach((b) => {
+        this.certificates.push(this.$scope.loadBalancerCmd.certificates[b]);
+      });
+    }
+  }
+
+  public initializeController() {
+    if (this.loadBalancer) {
+      this.$scope.loadBalancerCmd = this.oracleLoadBalancerTransformer.convertLoadBalancerForEditing(this.loadBalancer);
+      this.initControllerFromLoadBalancerCmd();
+      if (this.isNew) {
+        const nameParts = NameUtils.parseLoadBalancerName(this.loadBalancer.name);
+        this.$scope.loadBalancerCmd.stack = nameParts.stack;
+        this.$scope.loadBalancerCmd.detail = nameParts.freeFormDetails;
+        delete this.$scope.loadBalancerCmd.name;
+      }
+    } else {
+      this.$scope.loadBalancerCmd = this.oracleLoadBalancerTransformer.constructNewLoadBalancerTemplate(
+        this.application,
+      );
+    }
+    this.$scope.prevBackendSetNames = [];
+    this.$scope.prevCertNames = [];
+    if (this.isNew) {
+      this.updateName();
+      this.updateLoadBalancerNames();
+      this.initializeCreateMode();
+    }
+    this.$scope.taskMonitor = new TaskMonitor({
+      application: this.application,
+      title: (this.isNew ? 'Creating ' : 'Updating ') + 'your load balancer',
+      modalInstance: this.$uibModalInstance,
+      onTaskComplete: this.onTaskComplete,
+    });
+  }
+
+  public updateLoadBalancerNames() {
+    const account = this.$scope.loadBalancerCmd.credentials;
+    const region = this.$scope.loadBalancerCmd.region;
+
+    const accountLoadBalancerNamesByRegion: { [key: string]: string[] } = {};
+    this.application
+      .getDataSource('loadBalancers')
+      .refresh(true)
+      .then(() => {
+        const loadBalancers: ILoadBalancer[] = this.application.loadBalancers.data;
+        loadBalancers.forEach((loadBalancer) => {
+          if (loadBalancer.account === account) {
+            accountLoadBalancerNamesByRegion[loadBalancer.region] =
+              accountLoadBalancerNamesByRegion[loadBalancer.region] || [];
+            accountLoadBalancerNamesByRegion[loadBalancer.region].push(loadBalancer.name);
+          }
+        });
+
+        this.$scope.existingLoadBalancerNames = accountLoadBalancerNamesByRegion[region] || [];
+      });
+  }
+
+  public validateBeforeSubmit() {
+    return this.propertiesValid() && this.listenersValid();
+  }
+
+  /**
+   * Used to prevent form submission if listeners are invalid
+   * Currently it calls the two validations applicable to listeners.
+   * @returns {boolean}
+   */
+  public listenersValid() {
+    return this.listenersUniqueProtocolPort() && this.listenersBackendSetsExist() && this.listenersCertificatesExist();
+  }
+
+  /**
+   * Used to prevent form submission if the properties section is invalid
+   * Current the only validation is for subnet count.
+   */
+  public propertiesValid() {
+    return this.selectedSubnets && this.selectedSubnets.length === this.calcNumSubnetsAllowed();
+  }
+
+  public listenersUniqueProtocolPort() {
+    // validate that listeners have unique protocol/port combination
+    const countsMap: { [key: string]: number } = {};
+    this.listeners.reduce((counts, listener) => {
+      const protocolPort = listener.protocol + '_' + listener.port;
+      counts[protocolPort] = counts[protocolPort] ? counts[protocolPort] + 1 : 1;
+      return counts;
+    }, countsMap);
+    // There should be no protocol/port combo in the countsMap with a count > 1
+    return (
+      Object.keys(countsMap).filter((key) => {
+        return countsMap[key] > 1;
+      }).length === 0
+    );
+  }
+
+  public listenersBackendSetsExist() {
+    // validate that the listeners' selected backend sets must exist. This is needed because Angular
+    // does not clear the selected backendSet from the drop down if the backend set is deleted.
+    const listenersWithNonExistentBackendSet: IOracleListener[] = this.listeners.filter(
+      (listener) => !this.backendSets.find((backendSet) => backendSet.name === listener.defaultBackendSetName),
+    );
+    return listenersWithNonExistentBackendSet.length === 0;
+  }
+
+  public listenersCertificatesExist() {
+    // validate that the listeners' selected certificate names exist. This is needed because Angular
+    // does not clear the selected certificate from the drop down if the certificate is deleted.
+    const listenersWithNonExistentCertificate: IOracleListener[] = this.listeners.filter(
+      (listener) =>
+        listener.sslConfiguration &&
+        !this.certificates.find((cert) => cert.certificateName === listener.sslConfiguration.certificateName),
+    );
+    return listenersWithNonExistentCertificate.length === 0;
+  }
+
+  public updateName() {
+    this.$scope.loadBalancerCmd.name = this.getName();
+  }
+
+  public getName() {
+    const lb = this.$scope.loadBalancerCmd;
+    const lbName = [this.application.name, lb.stack || '', lb.detail || ''].join('-');
+    return trimEnd(lbName, '-');
+  }
+
+  public accountUpdated() {
+    this.loadRegionsForAccount();
+  }
+
+  public regionUpdated() {
+    this.updateLoadBalancerNames();
+    this.updateVnets();
+  }
+
+  public loadRegionsForAccount() {
+    AccountService.getRegionsForAccount(this.$scope.loadBalancerCmd.credentials).then((regions: IRegion[]) => {
+      this.$scope.regions = regions; // TODO desagar does this need to be in $scope?
+      if (regions.length === 1) {
+        this.$scope.loadBalancerCmd.region = regions[0].name;
+        this.regionUpdated();
+      }
+    });
+  }
+
+  public loadVnets() {
+    NetworkReader.listNetworksByProvider(this.oracle).then((vnets: INetwork[]) => {
+      this.allVnets = vnets || [];
+      if (this.$scope.loadBalancerCmd.region) {
+        this.updateVnets();
+      }
+    });
+  }
+
+  public loadSubnets() {
+    SubnetReader.listSubnetsByProvider(this.oracle).then((subnets: IOracleSubnet[]) => {
+      this.allSubnets = subnets || [];
+    });
+  }
+
+  public updateVnets() {
+    const account = this.$scope.loadBalancerCmd.credentials;
+    const region = this.$scope.loadBalancerCmd.region;
+    this.filteredVnets = this.allVnets.filter((vnet: INetwork) => {
+      return vnet.account === account && vnet.region === region;
+    });
+  }
+
+  public updateSubnets(network: INetwork) {
+    this.selectedSubnets = [];
+    this.$scope.loadBalancerCmd.subnetIds = [];
+    this.filteredSubnets = this.allSubnets.filter((subnet: IOracleSubnet) => {
+      return subnet.vcnId === network.id;
+    });
+    this.filteredSubnetsByType = cloneDeep(this.filteredSubnets);
+  }
+
+  public selectedVnetChanged(network: INetwork) {
+    this.selectedVnet = network;
+    this.$scope.loadBalancerCmd.vpcId = network.id;
+    this.updateSubnets(network);
+  }
+
+  public selectedSubnetsChanged(selectedSubnet: IOracleSubnet) {
+    if (selectedSubnet.availabilityDomain) {
+      this.filteredSubnetsByType = this.filteredSubnets.filter((subnet: IOracleSubnet) => {
+        return !!subnet.availabilityDomain;
+      });
+    } else {
+      this.filteredSubnetsByType = [];
+    }
+  }
+
+  public selectedSubnetRemoved() {
+    if (this.selectedSubnets.length === 0) {
+      this.filteredSubnetsByType = cloneDeep(this.filteredSubnets);
+    }
+    if (this.selectedSubnets.length === 1 && this.selectedSubnets[0].availabilityDomain) {
+      this.filteredSubnetsByType = this.filteredSubnets.filter((subnet: IOracleSubnet) => {
+        return !!subnet.availabilityDomain;
+      });
+    }
+  }
+
+  public isPrivateChanged() {
+    this.numSubnetsAllowed = this.calcNumSubnetsAllowed();
+  }
+
+  public listenerIsSslChanged(listener: IOracleListener) {
+    if (listener.isSsl) {
+      listener.sslConfiguration = this.oracleLoadBalancerTransformer.constructNewSSLConfiguration();
+    } else {
+      listener.sslConfiguration = undefined;
+    }
+  }
+
+  public calcNumSubnetsAllowed() {
+    if (this.$scope.loadBalancerCmd.isPrivate) {
+      return 1;
+    }
+
+    if (this.selectedSubnets && this.selectedSubnets.length === 1 && !this.selectedSubnets[0].availabilityDomain) {
+      return 1;
+    }
+
+    return 2;
+  }
+
+  public getSubnetLimit() {}
+
+  public removeListener(idx: number) {
+    this.listeners.splice(idx, 1);
+  }
+
+  public addListener() {
+    this.listeners.push(this.oracleLoadBalancerTransformer.constructNewListenerTemplate());
+  }
+
+  public removeBackendSet(idx: number) {
+    const backendSet = this.backendSets[idx];
+    this.backendSets.splice(idx, 1);
+    this.$scope.prevBackendSetNames.splice(idx, 1);
+    // Also clear the defaultBackendSetName field of any listeners who are using this backendSet
+    this.listeners.forEach((lis) => {
+      if (lis.defaultBackendSetName === backendSet.name) {
+        lis.defaultBackendSetName = undefined;
+      }
+    });
+  }
+
+  public isBackendSetRemovable(idx: number): boolean {
+    const backendSet = this.backendSets[idx];
+    if (backendSet && backendSet.backends && backendSet.backends.length > 0) {
+      return false;
+    }
+    let hasListener = false;
+    this.listeners.forEach((lis) => {
+      if (lis.defaultBackendSetName === backendSet.name) {
+        hasListener = true;
+      }
+    });
+    return !hasListener;
+  }
+
+  public addBackendSet() {
+    const nameSuffix: number = this.backendSets.length + 1;
+    const name: string = 'backendSet' + nameSuffix;
+    this.$scope.prevBackendSetNames.push(name);
+    this.backendSets.push(this.oracleLoadBalancerTransformer.constructNewBackendSetTemplate(name));
+  }
+
+  public backendSetNameChanged(idx: number) {
+    const prevName = this.$scope.prevBackendSetNames && this.$scope.prevBackendSetNames[idx];
+    if (prevName && prevName !== this.backendSets[idx].name) {
+      this.listeners
+        .filter((lis) => lis.defaultBackendSetName === prevName)
+        .forEach((lis) => {
+          lis.defaultBackendSetName = this.backendSets[idx].name;
+        });
+    }
+  }
+
+  public isCertRemovable(idx: number): boolean {
+    const cert = this.certificates[idx];
+    let hasListener = false;
+    this.listeners.forEach((lis) => {
+      if (lis.isSsl && lis.sslConfiguration && lis.sslConfiguration.certificateName === cert.certificateName) {
+        hasListener = true;
+      }
+    });
+    return !hasListener;
+  }
+
+  public removeCert(idx: number) {
+    const cert = this.certificates[idx];
+    this.certificates.splice(idx, 1);
+    this.$scope.prevCertNames.splice(idx, 1);
+    // Also clear the certificateName field of any listeners who are using this certificate
+    this.listeners.forEach((lis) => {
+      if (lis.sslConfiguration && lis.sslConfiguration.certificateName === cert.certificateName) {
+        lis.sslConfiguration.certificateName = undefined;
+      }
+    });
+  }
+
+  public addCert() {
+    const nameSuffix: number = this.certificates.length + 1;
+    const name: string = 'certificate' + nameSuffix;
+    this.$scope.prevCertNames.push(name);
+    this.certificates.push(this.oracleLoadBalancerTransformer.constructNewCertificateTemplate(name));
+  }
+
+  public certNameChanged(idx: number) {
+    const prevName = this.$scope.prevCertNames && this.$scope.prevCertNames[idx];
+    if (prevName && prevName !== this.certificates[idx].certificateName) {
+      this.listeners
+        .filter((lis) => lis.sslConfiguration && lis.sslConfiguration.certificateName === prevName)
+        .forEach((lis) => {
+          lis.sslConfiguration.certificateName = this.certificates[idx].certificateName;
+        });
+    }
+  }
+
+  public submit() {
+    const descriptor = this.isNew ? 'Create' : 'Update';
+
+    this.$scope.taskMonitor.submit(() => {
+      const params = {
+        cloudProvider: 'oracle',
+        application: this.application.name,
+        clusterName: this.$scope.loadBalancerCmd.clusterName,
+        resourceGroupName: this.$scope.loadBalancerCmd.clusterName,
+        loadBalancerName: this.$scope.loadBalancerCmd.name,
+        loadBalancerId: null as string,
+      };
+      if (this.loadBalancer && this.loadBalancer.id) {
+        params.loadBalancerId = this.loadBalancer.id;
+      }
+
+      if (this.selectedVnet) {
+        this.$scope.loadBalancerCmd.vpcId = this.selectedVnet.id;
+      }
+
+      if (this.selectedSubnets && this.selectedSubnets.length > 0) {
+        this.$scope.loadBalancerCmd.subnetIds = this.selectedSubnets.map((subnet: IOracleSubnet) => {
+          return subnet.id;
+        });
+
+        for (const subnet of this.selectedSubnets) {
+          if (!this.$scope.loadBalancerCmd.subnetTypeMap) {
+            this.$scope.loadBalancerCmd.subnetTypeMap = {
+              [subnet.id]: !subnet.availabilityDomain ? 'Regional' : 'AD',
+            };
+          } else {
+            this.$scope.loadBalancerCmd.subnetTypeMap[subnet.id] = !subnet.availabilityDomain ? 'Regional' : 'AD';
+          }
+        }
+      }
+
+      if (this.backendSets) {
+        this.$scope.loadBalancerCmd.backendSets = this.backendSets.reduce(
+          (backendSetsMap: { [name: string]: IOracleBackEndSet }, backendSet: IOracleBackEndSet) => {
+            backendSetsMap[backendSet.name] = backendSet;
+            return backendSetsMap;
+          },
+          {},
+        );
+      }
+
+      if (this.listeners) {
+        this.$scope.loadBalancerCmd.listeners = this.listeners.reduce(
+          (listenersMap: { [name: string]: IOracleListener }, listener: IOracleListener) => {
+            listener.name = listener.protocol + '_' + listener.port;
+            listenersMap[listener.name] = listener;
+            return listenersMap;
+          },
+          {},
+        );
+      }
+
+      if (this.certificates) {
+        this.$scope.loadBalancerCmd.certificates = this.certificates.reduce(
+          (certMap: { [name: string]: IOracleListenerCertificate }, cert: IOracleListenerCertificate) => {
+            certMap[cert.certificateName] = cert;
+            if (!cert.isNew) {
+              // existing certificate sends only the name
+              certMap[cert.certificateName].publicCertificate = null;
+            }
+            return certMap;
+          },
+          {},
+        );
+      }
+
+      this.$scope.loadBalancerCmd.type = 'upsertLoadBalancer';
+      if (!this.$scope.loadBalancerCmd.vnet && !this.$scope.loadBalancerCmd.subnetType) {
+        this.$scope.loadBalancerCmd.securityGroups = null;
+      }
+
+      return LoadBalancerWriter.upsertLoadBalancer(this.$scope.loadBalancerCmd, this.application, descriptor, params);
+    });
+  }
+
+  public cancel() {
+    this.$uibModalInstance.dismiss();
+  }
+}
+
+export const ORACLE_LOAD_BALANCER_CREATE_CONTROLLER = 'spinnaker.oracle.loadBalancer.create.controller';
+module(ORACLE_LOAD_BALANCER_CREATE_CONTROLLER, [
+  ANGULAR_UI_BOOTSTRAP as any,
+  UIROUTER_ANGULARJS,
+  ORACLE_LOAD_BALANCER_TRANSFORMER,
+]).controller('oracleCreateLoadBalancerCtrl', OracleLoadBalancerController);

package/src/loadBalancer/configure/createLoadBalancer.html

@@ -0,0 +1,25 @@
+<form name="form" class="form-horizontal" novalidate validate-on-submit>
+  <v2-modal-wizard heading="Create New Oracle Load Balancer" task-monitor="taskMonitor" dismiss="$dismiss()">
+    <v2-wizard-page key="Properties" label="Properties">
+      <ng-include src="ctrl.pages.properties"></ng-include>
+    </v2-wizard-page>
+    <v2-wizard-page key="Certificates" label="SSL Certificates" done="true">
+      <ng-include src="ctrl.pages.certificates"></ng-include>
+    </v2-wizard-page>
+    <v2-wizard-page key="Backend Sets" label="Backend Sets" done="true" hide-subheading="true">
+      <ng-include src="ctrl.pages.backendSets"></ng-include>
+    </v2-wizard-page>
+    <v2-wizard-page key="Listeners" label="Listeners" done="true">
+      <ng-include src="ctrl.pages.listeners"></ng-include>
+    </v2-wizard-page>
+  </v2-modal-wizard>
+  <div class="modal-footer">
+    <button ng-disabled="ctrl.taskMonitor.submitting" class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+    <submit-button
+      is-disabled="!state.accountsLoaded || !form.$valid || !ctrl.validateBeforeSubmit() || ctrl.taskMonitor.submitting"
+      submitting="ctrl.taskMonitor.submitting"
+      on-click="form.$valid && ctrl.validateBeforeSubmit() && ctrl.submit()"
+      is-new="ctrl.isNew"
+    ></submit-button>
+  </div>
+</form>