@spinnaker/oracle 2026.2.2 → 2026.3.0

package/src/securityGroup/securityGroup.reader.js

@@ -1,15 +1,7 @@
 'use strict';
 
-import { module } from 'angular';
-
-export const ORACLE_SECURITYGROUP_SECURITYGROUP_READER = 'spinnaker.oracle.securityGroup.reader';
-export const name = ORACLE_SECURITYGROUP_SECURITYGROUP_READER; // for backwards compatibility
-module(ORACLE_SECURITYGROUP_SECURITYGROUP_READER, []).factory('oracleSecurityGroupReader', function () {
-  function resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId) {
+export class OracleSecurityGroupReader {
+  resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId) {
     return indexedSecurityGroups[container.account][container.region][securityGroupId];
   }
-
-  return {
-    resolveIndexedSecurityGroup: resolveIndexedSecurityGroup,
-  };
-});
+}

package/src/securityGroup/securityGroup.transformer.js

@@ -1,25 +1,18 @@
 'use strict';
 
-import { module } from 'angular';
 import _ from 'lodash';
 
 import { NetworkReader } from '@spinnaker/core';
 
-export const ORACLE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER = 'spinnaker.oracle.securityGroup.transformer';
-export const name = ORACLE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER; // for backwards compatibility
-module(ORACLE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER, []).factory('oracleSecurityGroupTransformer', function () {
-  const provider = 'oracle';
-
-  function normalizeSecurityGroup(securityGroup) {
+export class OracleSecurityGroupTransformer {
+  normalizeSecurityGroup(securityGroup) {
     return NetworkReader.listNetworksByProvider(provider).then(_.partial(addVcnNameToSecurityGroup, securityGroup));
   }
+}
 
-  function addVcnNameToSecurityGroup(securityGroup, vcns) {
-    const matches = vcns.find((vcn) => vcn.id === securityGroup.network);
-    securityGroup.vpcName = matches.length ? matches[0].name : '';
-  }
+const provider = 'oracle';
 
-  return {
-    normalizeSecurityGroup: normalizeSecurityGroup,
-  };
-});
+function addVcnNameToSecurityGroup(securityGroup, vcns) {
+  const match = vcns.find((vcn) => vcn.id === securityGroup.network);
+  securityGroup.vpcName = match ? match.name : '';
+}

package/src/serverGroup/configure/serverGroupCommandBuilder.service.js

@@ -1,105 +1,89 @@
 'use strict';
 
-import * as angular from 'angular';
 import _ from 'lodash';
 
 import { NameUtils } from '@spinnaker/core';
 
 import { OracleProviderSettings } from '../../oracle.settings';
 
-export const ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE =
-  'spinnaker.oracle.serverGroupCommandBuilder.service';
-export const name = ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE; // for backwards compatibility
-angular
-  .module(ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE, [])
-  .factory('oracleServerGroupCommandBuilder', [
-    '$q',
-    function ($q) {
-      const oracle = 'oracle';
+const oracle = 'oracle';
 
-      function buildNewServerGroupCommand(application, defaults) {
-        defaults = defaults || {};
+export class OracleServerGroupCommandBuilder {
+  buildNewServerGroupCommand(application, defaults) {
+    defaults = defaults || {};
 
-        const defaultAccount = defaults.account || OracleProviderSettings.defaults.account;
-        const defaultRegion = defaults.region || OracleProviderSettings.defaults.region;
+    const defaultAccount = defaults.account || OracleProviderSettings.defaults.account;
+    const defaultRegion = defaults.region || OracleProviderSettings.defaults.region;
 
-        const command = {
-          account: defaultAccount,
-          application: application.name,
-          capacity: {
-            desired: 1,
-          },
-          region: defaultRegion,
-          selectedProvider: oracle,
-          viewState: {
-            mode: defaults.mode || 'create',
-            disableStrategySelection: true,
-          },
-        };
+    const command = {
+      account: defaultAccount,
+      application: application.name,
+      capacity: {
+        desired: 1,
+      },
+      region: defaultRegion,
+      selectedProvider: oracle,
+      viewState: {
+        mode: defaults.mode || 'create',
+        disableStrategySelection: true,
+      },
+    };
 
-        return $q.when(command);
-      }
+    return Promise.resolve(command);
+  }
 
-      function buildServerGroupCommandFromExisting(application, serverGroup, mode) {
-        mode = mode || 'clone';
-        const serverGroupName = NameUtils.parseServerGroupName(serverGroup.name);
+  buildServerGroupCommandFromExisting(application, serverGroup, mode) {
+    mode = mode || 'clone';
+    const serverGroupName = NameUtils.parseServerGroupName(serverGroup.name);
 
-        const command = {
-          account: serverGroup.account,
-          application: application.name,
-          shape: serverGroup.launchConfig.shape,
-          strategy: '',
-          stack: serverGroupName.stack,
-          vpcId: serverGroup.launchConfig.vpcId,
-          subnetId: serverGroup.launchConfig.subnetId,
-          region: serverGroup.region,
-          availabilityDomain: serverGroup.launchConfig.availabilityDomain,
-          sshAuthorizedKeys: serverGroup.launchConfig.sshAuthorizedKeys,
-          selectedProvider: oracle,
-          capacity: {
-            desired: serverGroup.capacity.desired,
-          },
-          viewState: {
-            mode: mode,
-            disableStrategySelection: true,
-          },
-        };
-        return $q.when(command);
-      }
+    const command = {
+      account: serverGroup.account,
+      application: application.name,
+      shape: serverGroup.launchConfig.shape,
+      strategy: '',
+      stack: serverGroupName.stack,
+      vpcId: serverGroup.launchConfig.vpcId,
+      subnetId: serverGroup.launchConfig.subnetId,
+      region: serverGroup.region,
+      availabilityDomain: serverGroup.launchConfig.availabilityDomain,
+      sshAuthorizedKeys: serverGroup.launchConfig.sshAuthorizedKeys,
+      selectedProvider: oracle,
+      capacity: {
+        desired: serverGroup.capacity.desired,
+      },
+      viewState: {
+        mode: mode,
+        disableStrategySelection: true,
+      },
+    };
+    return Promise.resolve(command);
+  }
 
-      function buildServerGroupCommandFromPipeline(application, originalCluster) {
-        const pipelineCluster = _.cloneDeep(originalCluster);
-        const commandDefaults = { account: pipelineCluster.account, region: pipelineCluster.region };
-        return buildNewServerGroupCommand(application, commandDefaults).then((command) => {
-          const viewState = {
-            disableImageSelection: true,
-            mode: 'editPipeline',
-            submitButtonLabel: 'Done',
-            templatingEnabled: true,
-          };
-
-          const viewOverrides = {
-            viewState: viewState,
-          };
+  buildServerGroupCommandFromPipeline(application, originalCluster) {
+    const pipelineCluster = _.cloneDeep(originalCluster);
+    const commandDefaults = { account: pipelineCluster.account, region: pipelineCluster.region };
+    return this.buildNewServerGroupCommand(application, commandDefaults).then((command) => {
+      const viewState = {
+        disableImageSelection: true,
+        mode: 'editPipeline',
+        submitButtonLabel: 'Done',
+        templatingEnabled: true,
+      };
 
-          pipelineCluster.strategy = pipelineCluster.strategy || '';
-          return angular.extend({}, command, pipelineCluster, viewOverrides);
-        });
-      }
+      const viewOverrides = {
+        viewState: viewState,
+      };
 
-      function buildNewServerGroupCommandForPipeline() {
-        return $q.when({
-          viewState: {
-            requiresTemplateSelection: true,
-          },
-        });
-      }
+      pipelineCluster.strategy = pipelineCluster.strategy || '';
+      return _.assign({}, command, pipelineCluster, viewOverrides);
+    });
+  }
 
-      return {
-        buildNewServerGroupCommand: buildNewServerGroupCommand,
-        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
-        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
-        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
-      };
-    },
-  ]);
+  buildNewServerGroupCommandForPipeline() {
+    return Promise.resolve({
+      viewState: {
+        requiresTemplateSelection: true,
+      },
+    });
+  }
+}

package/src/serverGroup/configure/serverGroupConfiguration.service.js

@@ -1,229 +1,225 @@
 'use strict';
 
-import { module } from 'angular';
 import _ from 'lodash';
 
-import { AccountService, NetworkReader, SECURITY_GROUP_READER, SubnetReader } from '@spinnaker/core';
+import { AccountService, NetworkReader, SubnetReader } from '@spinnaker/core';
+
+import { OracleImageReader } from '../../image/image.reader';
 import { OracleProviderSettings } from '../../oracle.settings';
 
-export const ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE =
-  'spinnaker.oracle.serverGroup.configure.configuration.service';
-export const name = ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE; // for backwards compatibility
-module(ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE, [SECURITY_GROUP_READER]).factory(
-  'oracleServerGroupConfigurationService',
-  [
-    '$q',
-    'oracleImageReader',
-    'securityGroupReader',
-    function ($q, oracleImageReader, securityGroupReader) {
-      const oracle = 'oracle';
-
-      const getShapes = (image) => {
-        if (!image || !image.compatibleShapes) {
-          return [];
-        }
-        return image.compatibleShapes.map((shape) => {
-          return { name: shape };
-        });
-      };
+const oracle = 'oracle';
 
-      const loadAndSelectRegions = (command, backingData) => {
-        if (command.account) {
-          const selectedAccountDetails = backingData.credentialsKeyedByAccount[command.account];
-          if (!selectedAccountDetails) {
-            return;
-          }
-          backingData.filtered.regions = _.map(selectedAccountDetails.regions, (region) => {
-            return { name: region.name };
-          });
-          if (selectedAccountDetails) {
-            command.region = selectedAccountDetails.region;
-          }
-        }
-      };
-
-      const loadAvailabilityDomains = (command) => {
-        if (command.account && command.region) {
-          AccountService.getAvailabilityZonesForAccountAndRegion(oracle, command.account, command.region).then(
-            (availDoms) => {
-              if (availDoms) {
-                command.backingData.filtered.availabilityDomains = availDoms.map((av) => {
-                  return { name: av };
-                });
-              } else {
-                command.backingData.filtered.availabilityDomains = [];
-                command.availabilityDomain = null;
-              }
-            },
-          );
-        }
-      };
+export class OracleServerGroupConfigurationService {
+  static requiresDeckRuntimeServices = true;
 
-      const loadLoadBalancers = (command) => {
-        if (command.account && command.region) {
-          command.backingData.filtered.loadBalancers = command.backingData.loadBalancers.filter(function (lb) {
-            return lb.region === command.region && lb.account === command.account;
-          });
-        }
-      };
-
-      function configureCommand(application, command) {
-        const defaults = command || {};
-        const defaultCredentials =
-          defaults.account || application.defaultCredentials.oracle || OracleProviderSettings.defaults.account;
-        const defaultRegion =
-          defaults.region || application.defaultRegions.oracle || OracleProviderSettings.defaults.region;
-
-        return $q
-          .all([
-            AccountService.getCredentialsKeyedByAccount(oracle),
-            NetworkReader.listNetworksByProvider(oracle),
-            SubnetReader.listSubnetsByProvider(oracle),
-            securityGroupReader.getAllSecurityGroups(),
-            loadImages(),
-            AccountService.getAvailabilityZonesForAccountAndRegion(oracle, defaultCredentials, defaultRegion),
-          ])
-          .then(function ([credentialsKeyedByAccount, networks, subnets, securityGroups, images, availDomains]) {
-            const backingData = {
-              credentialsKeyedByAccount,
-              networks,
-              subnets,
-              securityGroups,
-              images,
-              availDomains,
-            };
-
-            backingData.accounts = _.keys(backingData.credentialsKeyedByAccount);
-            backingData.filtered = {};
-            loadAndSelectRegions(command, backingData);
-            backingData.filtered.availabilityDomains = _.map(backingData.availDomains, function (zone) {
-              return { name: zone };
-            });
+  constructor(_promiseService, runtimeServices) {
+    this.oracleImageReader = new OracleImageReader();
+    this.securityGroupReader = runtimeServices.securityGroupReader;
+  }
 
-            backingData.filterSubnets = function () {
-              if (command.vpcId && command.availabilityDomain) {
-                return _.filter(backingData.subnets, {
-                  vcnId: command.vpcId,
-                  availabilityDomain: command.availabilityDomain,
-                });
-              }
-              return backingData.subnets;
-            };
-
-            backingData.loadBalancers = application.loadBalancers.data;
-
-            backingData.accountOnChange = function () {
-              loadAndSelectRegions(command, command.backingData);
-              loadAvailabilityDomains(command);
-              loadLoadBalancers(command);
-            };
-
-            backingData.regionOnChange = function () {
-              loadAvailabilityDomains(command);
-              loadLoadBalancers(command);
-            };
-
-            backingData.availabilityDomainOnChange = function () {
-              command.subnetId = null;
-              backingData.seclists = null;
-            };
-
-            backingData.vpcOnChange = function () {
-              command.subnetId = null;
-              backingData.seclists = null;
-            };
-
-            backingData.subnetOnChange = function () {
-              const subnet = _.find(backingData.subnets, { id: command.subnetId });
-              const mySecGroups = backingData.securityGroups[command.account][oracle][command.region];
-              const secLists = [];
-              _.forEach(subnet.securityListIds, function (sid) {
-                const sgRef = _.find(mySecGroups, { id: sid });
-                securityGroupReader
-                  .getSecurityGroupDetails(
-                    command.application,
-                    command.account,
-                    oracle,
-                    command.region,
-                    command.vpcId,
-                    sgRef.name,
-                  )
-                  .then(function (sgd) {
-                    secLists.push(sgd);
-                    backingData.seclists = secLists;
-                  });
+  configureCommand(application, command) {
+    const oracleImageReader = this.oracleImageReader;
+    const securityGroupReader = this.securityGroupReader;
+
+    const getShapes = (image) => {
+      if (!image || !image.compatibleShapes) {
+        return [];
+      }
+      return image.compatibleShapes.map((shape) => {
+        return { name: shape };
+      });
+    };
+
+    const loadAndSelectRegions = (command, backingData) => {
+      if (command.account) {
+        const selectedAccountDetails = backingData.credentialsKeyedByAccount[command.account];
+        if (!selectedAccountDetails) {
+          return;
+        }
+        backingData.filtered.regions = _.map(selectedAccountDetails.regions, (region) => {
+          return { name: region.name };
+        });
+        if (selectedAccountDetails) {
+          command.region = selectedAccountDetails.region;
+        }
+      }
+    };
+
+    const loadAvailabilityDomains = (command) => {
+      if (command.account && command.region) {
+        AccountService.getAvailabilityZonesForAccountAndRegion(oracle, command.account, command.region).then(
+          (availDoms) => {
+            if (availDoms) {
+              command.backingData.filtered.availabilityDomains = availDoms.map((av) => {
+                return { name: av };
               });
-            };
-
-            backingData.findBackendSetsByLoadBalancerId = (loadBalancerId) => {
-              const lb = backingData.filtered.loadBalancers.find((lb) => lb.id === loadBalancerId);
-              if (lb && lb.backendSets) {
-                //reduce the backendSets object to an array. The object is keyed by the backendSet name
-                const bsetArray = [];
-                Object.keys(lb.backendSets).reduce((arr, bsetName) => {
-                  const bset = lb.backendSets[bsetName];
-                  bset['name'] = bsetName;
-                  arr.push(bset);
-                  return arr;
-                }, bsetArray);
-                return bsetArray;
-              } else {
-                return [];
-              }
-            };
-
-            backingData.findLoadBalListenersByBackendSetName = (loadBalancerId, backendSetName) => {
-              const lb = backingData.filtered.loadBalancers.find((lb) => lb.id === loadBalancerId);
-              if (lb && lb.listeners) {
-                return Object.keys(lb.listeners)
-                  .filter((lisName) => lb.listeners[lisName].defaultBackendSetName === backendSetName)
-                  .map((lisName) => lb.listeners[lisName]);
-              } else {
-                return [];
-              }
-            };
-
-            backingData.loadBalancerOnChange = () => {
-              if (command.loadBalancerId) {
-                backingData.filtered.backendSets = backingData.findBackendSetsByLoadBalancerId(command.loadBalancerId);
-              } else {
-                //no backend set name should be set if no load balancer id is set
-                command.backendSetName = undefined;
-                backingData.backendSetOnChange();
-                backingData.filtered.backendSets = [];
-              }
-            };
-
-            backingData.backendSetOnChange = () => {
-              backingData.filtered.listeners =
-                command.loadBalancerId && command.backendSetName
-                  ? backingData.findLoadBalListenersByBackendSetName(command.loadBalancerId, command.backendSetName)
-                  : [];
-            };
-
-            backingData.filtered.images = backingData.images;
-            const shapesMap = {};
-            _.forEach(backingData.filtered.images, (image) => {
-              shapesMap[image.id] = getShapes(image);
-            });
-            backingData.filtered.shapes = shapesMap;
-            backingData.filtered.allShapes = _.uniqBy(_.flatten(_.values(shapesMap)), 'name');
-            command.backingData = backingData;
-            if (command.account) {
-              loadLoadBalancers(command);
-              backingData.loadBalancerOnChange();
-              backingData.backendSetOnChange();
+            } else {
+              command.backingData.filtered.availabilityDomains = [];
+              command.availabilityDomain = null;
             }
-          });
+          },
+        );
       }
+    };
 
-      function loadImages() {
-        return oracleImageReader.findImages({ provider: oracle });
+    const loadLoadBalancers = (command) => {
+      if (command.account && command.region) {
+        command.backingData.filtered.loadBalancers = command.backingData.loadBalancers.filter(function (lb) {
+          return lb.region === command.region && lb.account === command.account;
+        });
       }
+    };
+
+    {
+      const defaults = command || {};
+      const defaultCredentials =
+        defaults.account || application.defaultCredentials.oracle || OracleProviderSettings.defaults.account;
+      const defaultRegion =
+        defaults.region || application.defaultRegions.oracle || OracleProviderSettings.defaults.region;
+
+      return Promise.all([
+        AccountService.getCredentialsKeyedByAccount(oracle),
+        NetworkReader.listNetworksByProvider(oracle),
+        SubnetReader.listSubnetsByProvider(oracle),
+        securityGroupReader.getAllSecurityGroups(),
+        loadImages(),
+        AccountService.getAvailabilityZonesForAccountAndRegion(oracle, defaultCredentials, defaultRegion),
+      ]).then(function ([credentialsKeyedByAccount, networks, subnets, securityGroups, images, availDomains]) {
+        const backingData = {
+          credentialsKeyedByAccount,
+          networks,
+          subnets,
+          securityGroups,
+          images,
+          availDomains,
+        };
+
+        backingData.accounts = _.keys(backingData.credentialsKeyedByAccount);
+        backingData.filtered = {};
+        loadAndSelectRegions(command, backingData);
+        backingData.filtered.availabilityDomains = _.map(backingData.availDomains, function (zone) {
+          return { name: zone };
+        });
 
-      return {
-        configureCommand: configureCommand,
-      };
-    },
-  ],
-);
+        backingData.filterSubnets = function () {
+          if (command.vpcId && command.availabilityDomain) {
+            return _.filter(backingData.subnets, {
+              vcnId: command.vpcId,
+              availabilityDomain: command.availabilityDomain,
+            });
+          }
+          return backingData.subnets;
+        };
+
+        backingData.loadBalancers = application.loadBalancers.data;
+
+        backingData.accountOnChange = function () {
+          loadAndSelectRegions(command, command.backingData);
+          loadAvailabilityDomains(command);
+          loadLoadBalancers(command);
+        };
+
+        backingData.regionOnChange = function () {
+          loadAvailabilityDomains(command);
+          loadLoadBalancers(command);
+        };
+
+        backingData.availabilityDomainOnChange = function () {
+          command.subnetId = null;
+          backingData.seclists = null;
+        };
+
+        backingData.vpcOnChange = function () {
+          command.subnetId = null;
+          backingData.seclists = null;
+        };
+
+        backingData.subnetOnChange = function () {
+          const subnet = _.find(backingData.subnets, { id: command.subnetId });
+          const mySecGroups = backingData.securityGroups[command.account][oracle][command.region];
+          const secLists = [];
+          _.forEach(subnet.securityListIds, function (sid) {
+            const sgRef = _.find(mySecGroups, { id: sid });
+            securityGroupReader
+              .getSecurityGroupDetails(
+                command.application,
+                command.account,
+                oracle,
+                command.region,
+                command.vpcId,
+                sgRef.name,
+              )
+              .then(function (sgd) {
+                secLists.push(sgd);
+                backingData.seclists = secLists;
+              });
+          });
+        };
+
+        backingData.findBackendSetsByLoadBalancerId = (loadBalancerId) => {
+          const lb = backingData.filtered.loadBalancers.find((lb) => lb.id === loadBalancerId);
+          if (lb && lb.backendSets) {
+            //reduce the backendSets object to an array. The object is keyed by the backendSet name
+            const bsetArray = [];
+            Object.keys(lb.backendSets).reduce((arr, bsetName) => {
+              const bset = lb.backendSets[bsetName];
+              bset['name'] = bsetName;
+              arr.push(bset);
+              return arr;
+            }, bsetArray);
+            return bsetArray;
+          } else {
+            return [];
+          }
+        };
+
+        backingData.findLoadBalListenersByBackendSetName = (loadBalancerId, backendSetName) => {
+          const lb = backingData.filtered.loadBalancers.find((lb) => lb.id === loadBalancerId);
+          if (lb && lb.listeners) {
+            return Object.keys(lb.listeners)
+              .filter((lisName) => lb.listeners[lisName].defaultBackendSetName === backendSetName)
+              .map((lisName) => lb.listeners[lisName]);
+          } else {
+            return [];
+          }
+        };
+
+        backingData.loadBalancerOnChange = () => {
+          if (command.loadBalancerId) {
+            backingData.filtered.backendSets = backingData.findBackendSetsByLoadBalancerId(command.loadBalancerId);
+          } else {
+            //no backend set name should be set if no load balancer id is set
+            command.backendSetName = undefined;
+            backingData.backendSetOnChange();
+            backingData.filtered.backendSets = [];
+          }
+        };
+
+        backingData.backendSetOnChange = () => {
+          backingData.filtered.listeners =
+            command.loadBalancerId && command.backendSetName
+              ? backingData.findLoadBalListenersByBackendSetName(command.loadBalancerId, command.backendSetName)
+              : [];
+        };
+
+        backingData.filtered.images = backingData.images;
+        const shapesMap = {};
+        _.forEach(backingData.filtered.images, (image) => {
+          shapesMap[image.id] = getShapes(image);
+        });
+        backingData.filtered.shapes = shapesMap;
+        backingData.filtered.allShapes = _.uniqBy(_.flatten(_.values(shapesMap)), 'name');
+        command.backingData = backingData;
+        if (command.account) {
+          loadLoadBalancers(command);
+          backingData.loadBalancerOnChange();
+          backingData.backendSetOnChange();
+        }
+      });
+    }
+
+    function loadImages() {
+      return oracleImageReader.findImages({ provider: oracle });
+    }
+  }
+}