@spinnaker/amazon 2026.2.3 → 2026.3.0

package/src/instance/details/instance.details.controller.spec.js

@@ -1,133 +0,0 @@
-import { ApplicationModelBuilder, InstanceReader } from '@spinnaker/core';
-
-describe('Controller: awsInstanceDetailsCtrl', function () {
-  var controller;
-  var scope;
-  var $q;
-  var application;
-
-  beforeEach(window.module(require('./instance.details.controller').name));
-
-  beforeEach(
-    window.inject(function ($rootScope, $controller, _$q_) {
-      scope = $rootScope.$new();
-      $q = _$q_;
-
-      this.createController = function (application, instance) {
-        controller = $controller('awsInstanceDetailsCtrl', {
-          $scope: scope,
-          app: application,
-          overrides: {},
-          moniker: {},
-          environment: 'test',
-          instance,
-        });
-      };
-
-      application = ApplicationModelBuilder.createApplicationForTests(
-        'app',
-        { key: 'loadBalancers', lazy: true, defaultData: [] },
-        { key: 'serverGroups', lazy: true, defaultData: [] },
-      );
-    }),
-  );
-
-  describe('health metrics', function () {
-    it('overrides new health with health from application, adding new fields', function () {
-      var details = {
-        health: [{ type: 'Discovery', status: 'Up', extra: 'details field', reason: 'mutated' }],
-      };
-      var params = {
-        instanceId: 'i-123',
-        region: 'us-west-1',
-        account: 'test',
-      };
-
-      spyOn(InstanceReader, 'getInstanceDetails').and.returnValue($q.when(details));
-
-      application.loadBalancers.loaded = true;
-
-      application.serverGroups.data = [
-        {
-          account: 'test',
-          region: 'us-west-1',
-          instances: [
-            {
-              id: 'i-123',
-              health: [{ type: 'Discovery', status: 'Down', reason: 'original reason' }],
-            },
-          ],
-        },
-      ];
-      application.serverGroups.loaded = true;
-
-      this.createController(application, params);
-      scope.$digest();
-
-      expect(scope.healthMetrics.length).toBe(1);
-      expect(scope.healthMetrics[0].reason).toBe('original reason');
-      expect(scope.healthMetrics[0].status).toBe('Down');
-      expect(scope.healthMetrics[0].extra).toBe('details field');
-    });
-  });
-
-  describe('canRegister methods', function () {
-    beforeEach(function () {
-      var details = {};
-      var params = {
-        instanceId: 'i-123',
-        region: 'us-west-1',
-        account: 'test',
-      };
-
-      spyOn(InstanceReader, 'getInstanceDetails').and.returnValue(
-        $q.when({
-          plain: function () {
-            return details;
-          },
-        }),
-      );
-
-      application.loadBalancers.loaded = true;
-
-      application.serverGroups.data = [
-        {
-          account: 'test',
-          region: 'us-west-1',
-          instances: [
-            {
-              id: 'i-123',
-              health: [{ type: 'Discovery', state: 'Up', reason: 'original reason' }],
-            },
-          ],
-        },
-      ];
-      application.serverGroups.loaded = true;
-
-      this.createController(application, params);
-      scope.$digest();
-    });
-
-    it('can register with discovery when discovery', function () {
-      expect(controller.canRegisterWithDiscovery()).toBe(false);
-      scope.instance.health[0].state = 'OutOfService';
-      expect(controller.canRegisterWithDiscovery()).toBe(true);
-      scope.instance.health[0].state = 'Down';
-      expect(controller.canRegisterWithDiscovery()).toBe(false);
-      scope.instance.health = [];
-      expect(controller.canRegisterWithDiscovery()).toBe(false);
-    });
-
-    it('can register with load balancer', function () {
-      expect(controller.canRegisterWithLoadBalancer()).toBe(false);
-      scope.instance.health[0].type = 'LoadBalancer';
-      scope.instance.health[0].state = 'OutOfService';
-      expect(controller.canRegisterWithLoadBalancer()).toBe(false);
-      // add a load balancer
-      scope.instance.loadBalancers = ['elb-1'];
-      expect(controller.canRegisterWithLoadBalancer()).toBe(true);
-      scope.instance.health[0].state = 'Up';
-      expect(controller.canRegisterWithLoadBalancer()).toBe(false);
-    });
-  });
-});

package/src/instance/details/instanceDetails.html

@@ -1,65 +0,0 @@
-<div class="text-center" ng-if="state.notFoundStandalone">
-  <h3>Could not find instance {{instanceIdNotFound}}.</h3>
-  <a ui-sref="home.infrastructure">Back to search results</a>
-</div>
-<div class="details-panel" ng-if="!state.notFoundStandalone">
-  <div class="header">
-    <instance-details-header
-      health-state="instance.healthState"
-      instance-id="instance.instanceId || instanceIdNotFound"
-      loading="state.loading"
-      standalone="state.standalone"
-    ></instance-details-header>
-    <div ng-if="!state.loading" ng-hide="isDisabled">
-      <div class="actions" ng-class="{ insights: instance.insightActions.length > 0 }" ng-if="instance.placement">
-        <instance-actions actions="instanceActions"></instance-actions>
-        <instance-insights insights="instance.insightActions" instance="instance"></instance-insights>
-      </div>
-    </div>
-  </div>
-  <div class="content" ng-if="!state.loading && instance">
-    <amazon-instance-information instance="instance"></amazon-instance-information>
-    <instance-status
-      health-metrics="healthMetrics"
-      health-state="instance.healthState"
-      metric-types="['LoadBalancer', 'TargetGroup']"
-      private-ip-address="instance.privateIpAddress"
-    >
-    </instance-status>
-    <collapsible-section heading="DNS">
-      <instance-dns
-        instance-port="state.instancePort"
-        ipv6-addresses="instance.ipv6Addresses"
-        permanent-ips="instance.permanentIps"
-        private-dns-name="instance.privateDnsName"
-        private-ip-address="instance.privateIpAddress"
-        public-dns-name="instance.publicDnsName"
-        public-ip-address="instance.publicIpAddress"
-      >
-      </instance-dns>
-    </collapsible-section>
-    <instance-security-groups instance="instance"></instance-security-groups>
-    <instance-tags tags="instance.tags"></instance-tags>
-    <collapsible-section heading="Console Output" ng-if="baseIpAddress">
-      <ul>
-        <li>
-          <console-output-link instance="instance"></console-output-link>
-        </li>
-      </ul>
-    </collapsible-section>
-    <instance-links
-      address="baseIpAddress"
-      application="application"
-      instance="instance"
-      moniker="moniker"
-      environment="environment"
-    ></instance-links>
-  </div>
-  <div class="content" ng-if="!state.loading && !instance">
-    <div class="content-section">
-      <div class="content-body text-center">
-        <h3>Instance not found.</h3>
-      </div>
-    </div>
-  </div>
-</div>

package/src/instance/details/instanceDns.component.ts

@@ -1,21 +0,0 @@
-import { module } from 'angular';
-import { react2angular } from 'react2angular';
-
-import { withErrorBoundary } from '@spinnaker/core';
-
-import { InstanceDns } from './InstanceDns';
-
-export const INSTANCE_DNS_COMPONENT = 'spinnaker.application.instanceDns.component';
-
-module(INSTANCE_DNS_COMPONENT, []).component(
-  'instanceDns',
-  react2angular(withErrorBoundary(InstanceDns, 'instanceDns'), [
-    'instancePort',
-    'ipv6Addresses',
-    'permanentIps',
-    'privateDnsName',
-    'privateIpAddress',
-    'publicDnsName',
-    'publicIpAddress',
-  ]),
-);

package/src/instance/details/instanceSecurityGroups.component.ts

@@ -1,13 +0,0 @@
-import { module } from 'angular';
-import { react2angular } from 'react2angular';
-
-import { withErrorBoundary } from '@spinnaker/core';
-
-import { InstanceSecurityGroups } from './InstanceSecurityGroups';
-
-export const INSTANCE_SECURITY_GROUPS_COMPONENT = 'spinnaker.application.instanceSecurityGroups.component';
-
-module(INSTANCE_SECURITY_GROUPS_COMPONENT, []).component(
-  'instanceSecurityGroups',
-  react2angular(withErrorBoundary(InstanceSecurityGroups, 'instanceSecurityGroups'), ['instance']),
-);

package/src/instance/details/instanceStatus.component.ts

@@ -1,19 +0,0 @@
-import { module } from 'angular';
-import { react2angular } from 'react2angular';
-
-import { withErrorBoundary } from '@spinnaker/core';
-
-import { InstanceStatus } from './InstanceStatus';
-
-export const INSTANCE_STATUS_COMPONENT = 'spinnaker.application.instanceStatus.component';
-
-module(INSTANCE_STATUS_COMPONENT, []).component(
-  'instanceStatus',
-  react2angular(withErrorBoundary(InstanceStatus, 'instanceStatus'), [
-    'healthMetrics',
-    'healthState',
-    'metricTypes',
-    'customHealthUrl',
-    'privateIpAddress',
-  ]),
-);

package/src/instance/details/instanceTags.component.ts

@@ -1,13 +0,0 @@
-import { module } from 'angular';
-import { react2angular } from 'react2angular';
-
-import { withErrorBoundary } from '@spinnaker/core';
-
-import { InstanceTags } from './InstanceTags';
-
-export const INSTANCE_TAGS_COMPONENT = 'spinnaker.application.instanceTags.component';
-
-module(INSTANCE_TAGS_COMPONENT, []).component(
-  'instanceTags',
-  react2angular(withErrorBoundary(InstanceTags, 'instanceTags'), ['tags']),
-);

package/src/loadBalancer/details/loadBalancerActions.component.ts

@@ -1,16 +0,0 @@
-import { module } from 'angular';
-import { react2angular } from 'react2angular';
-
-import { withErrorBoundary } from '@spinnaker/core';
-
-import { LoadBalancerActions } from './LoadBalancerActions';
-
-export const LOAD_BALANCER_ACTIONS = 'spinnaker.amazon.loadBalancer.details.loadBalancerActions.component';
-module(LOAD_BALANCER_ACTIONS, []).component(
-  'loadBalancerActions',
-  react2angular(withErrorBoundary(LoadBalancerActions, 'loadBalancerActions'), [
-    'app',
-    'loadBalancer',
-    'loadBalancerFromParams',
-  ]),
-);

package/src/loadBalancer/details/loadBalancerDetails.controller.spec.ts

@@ -1,76 +0,0 @@
-import type { StateService } from '@uirouter/core';
-import type { IControllerService, IRootScopeService } from 'angular';
-import { mock } from 'angular';
-
-import type { ISubnet } from '@spinnaker/core';
-import { ApplicationModelBuilder } from '@spinnaker/core';
-
-import { AWS_LOAD_BALANCER_DETAILS_CTRL, AwsLoadBalancerDetailsController } from './loadBalancerDetails.controller';
-
-describe('Controller: LoadBalancerDetailsCtrl', function () {
-  let controller: AwsLoadBalancerDetailsController;
-  let $scope;
-  let $state;
-  const loadBalancer = {
-    name: 'foo',
-    region: 'us-west-1',
-    account: 'test',
-    accountId: 'test',
-    vpcId: '1',
-  };
-
-  beforeEach(mock.module(AWS_LOAD_BALANCER_DETAILS_CTRL));
-
-  beforeEach(
-    mock.inject(($controller: IControllerService, $rootScope: IRootScopeService, _$state_: StateService) => {
-      $scope = $rootScope.$new();
-      $state = _$state_;
-      const app = ApplicationModelBuilder.createApplicationForTests('app', {
-        key: 'loadBalancers',
-        lazy: true,
-        defaultData: [],
-      });
-      app.loadBalancers.data.push(loadBalancer);
-      controller = $controller(AwsLoadBalancerDetailsController, {
-        $scope,
-        loadBalancer,
-        app,
-        $state,
-      });
-    }),
-  );
-
-  it('should have an instantiated controller', function () {
-    expect(controller).toBeDefined();
-  });
-
-  describe('Get the first subnets purpose', function () {
-    it('should return empty string if there are no subnets ', function () {
-      const subnetDetails: ISubnet[] = [];
-      const result = controller.getFirstSubnetPurpose(subnetDetails);
-      expect(result).toEqual('');
-    });
-
-    it('should return empty string if no subnetDetail is submitted', function () {
-      const result = controller.getFirstSubnetPurpose();
-      expect(result).toEqual('');
-    });
-
-    it('should return empty string if undefined subnetDetail is submitted', function () {
-      const result = controller.getFirstSubnetPurpose(undefined);
-      expect(result).toEqual('');
-    });
-
-    it('should return the first purpose of subnetDetail if there is only one', function () {
-      const subnetDetails = [{ purpose: 'internal(vpc0)' }] as ISubnet[];
-      const result = controller.getFirstSubnetPurpose(subnetDetails);
-      expect(result).toEqual('internal(vpc0)');
-    });
-
-    it('should return the first purpose of subnetDetail if there are multiple', function () {
-      const subnetDetails = [{ purpose: 'internal(vpc0)' }, { purpose: 'internal(vpc1)' }] as ISubnet[];
-      const result = controller.getFirstSubnetPurpose(subnetDetails);
-      expect(result).toEqual('internal(vpc0)');
-    });
-  });
-});

package/src/loadBalancer/details/loadBalancerDetails.controller.ts

@@ -1,240 +0,0 @@
-import type { StateService } from '@uirouter/angularjs';
-import UIROUTER_ANGULARJS from '@uirouter/angularjs';
-import type { IController, IQService, IScope } from 'angular';
-import { module } from 'angular';
-import { head, sortBy } from 'lodash';
-
-import type {
-  Application,
-  IApplicationSecurityGroup,
-  ILoadBalancer,
-  ISecurityGroup,
-  ISubnet,
-  LoadBalancerReader,
-  SecurityGroupReader,
-} from '@spinnaker/core';
-import {
-  FirewallLabels,
-  LOAD_BALANCER_READ_SERVICE,
-  MANAGED_RESOURCE_DETAILS_INDICATOR,
-  SECURITY_GROUP_READER,
-  SETTINGS,
-  SubnetReader,
-} from '@spinnaker/core';
-import type {
-  IAmazonApplicationLoadBalancer,
-  IAmazonLoadBalancer,
-  IAmazonLoadBalancerSourceData,
-  IApplicationLoadBalancerSourceData,
-  IClassicLoadBalancerSourceData,
-  IListenerAction,
-  ITargetGroup,
-} from '../../domain';
-
-import { LOAD_BALANCER_ACTIONS } from './loadBalancerActions.component';
-
-export interface ILoadBalancerFromStateParams {
-  accountId: string;
-  region: string;
-  name: string;
-}
-
-export interface IActionDetails extends IListenerAction {
-  targetGroup: ITargetGroup;
-}
-
-export class AwsLoadBalancerDetailsController implements IController {
-  public application: Application;
-  public elbProtocol: string;
-  public listeners: Array<{ in: string; actions: IActionDetails[] }>;
-  public loadBalancerFromParams: ILoadBalancerFromStateParams;
-  public loadBalancer: IAmazonLoadBalancer;
-  public securityGroups: ISecurityGroup[];
-  public ipAddressTypeDescription: string;
-  public state = { loading: true };
-  public firewallsLabel = FirewallLabels.get('Firewalls');
-  public oidcConfigPath = SETTINGS.oidcConfigPath;
-
-  public static $inject = [
-    '$scope',
-    '$state',
-    '$q',
-    'loadBalancer',
-    'app',
-    'securityGroupReader',
-    'loadBalancerReader',
-  ];
-  constructor(
-    private $scope: IScope,
-    private $state: StateService,
-    private $q: IQService,
-    loadBalancer: ILoadBalancerFromStateParams,
-    private app: Application,
-    private securityGroupReader: SecurityGroupReader,
-    private loadBalancerReader: LoadBalancerReader,
-  ) {
-    this.application = app;
-    this.loadBalancerFromParams = loadBalancer;
-
-    this.app
-      .ready()
-      .then(() => this.extractLoadBalancer())
-      .then(() => {
-        // If the user navigates away from the view before the initial extractLoadBalancer call completes,
-        // do not bother subscribing to the refresh
-        if (!$scope.$$destroyed) {
-          app.getDataSource('loadBalancers').onRefresh($scope, () => this.extractLoadBalancer());
-        }
-      });
-  }
-
-  public autoClose(): void {
-    if (this.$scope.$$destroyed) {
-      return;
-    }
-    this.$state.params.allowModalToStayOpen = true;
-    this.$state.go('^', null, { location: 'replace' });
-  }
-
-  public extractLoadBalancer(): PromiseLike<void> {
-    const appLoadBalancer = this.app.loadBalancers.data.find((test: ILoadBalancer) => {
-      return (
-        test.name === this.loadBalancerFromParams.name &&
-        test.region === this.loadBalancerFromParams.region &&
-        test.account === this.loadBalancerFromParams.accountId
-      );
-    });
-
-    if (appLoadBalancer) {
-      const detailsLoader = this.loadBalancerReader.getLoadBalancerDetails(
-        'aws',
-        this.loadBalancerFromParams.accountId,
-        this.loadBalancerFromParams.region,
-        this.loadBalancerFromParams.name,
-      );
-      return detailsLoader.then(
-        (details: IAmazonLoadBalancerSourceData[]) => {
-          this.loadBalancer = appLoadBalancer;
-          this.state.loading = false;
-          const securityGroups: IApplicationSecurityGroup[] = [];
-          if (details.length) {
-            this.loadBalancer.elb = details[0];
-            this.loadBalancer.elb.vpcId = this.loadBalancer.elb.vpcId || this.loadBalancer.elb.vpcid;
-            this.loadBalancer.account = this.loadBalancerFromParams.accountId;
-
-            const sourceData = details[0] as IApplicationLoadBalancerSourceData;
-            if (sourceData.loadBalancerType === 'application' || sourceData.loadBalancerType === 'network') {
-              // Transform listener data
-              const elb = details[0] as IApplicationLoadBalancerSourceData;
-              if (elb.listeners && elb.listeners.length) {
-                this.elbProtocol = 'http:';
-                if (elb.listeners.some((l: any) => l.protocol === 'HTTPS')) {
-                  this.elbProtocol = 'https:';
-                }
-
-                this.listeners = [];
-
-                // Sort the actions by the order specified since amazon does not return them in order of order
-                elb.listeners.forEach((l) => {
-                  l.defaultActions.sort((a, b) => a.order - b.order);
-                  l.rules.forEach((r) => r.actions.sort((a, b) => a.order - b.order));
-                });
-
-                elb.listeners.forEach((listener) => {
-                  listener.rules.map((rule) => {
-                    let inMatch = [
-                      listener.protocol,
-                      (rule.conditions.find((c) => c.field === 'host-header') || { values: [''] }).values[0],
-                      listener.port,
-                    ]
-                      .filter((f) => f)
-                      .join(':');
-                    const path = (rule.conditions.find((c) => c.field === 'path-pattern') || { values: [] }).values[0];
-                    if (path) {
-                      inMatch = `${inMatch}${path}`;
-                    }
-                    const actions = rule.actions.map((a) => {
-                      const action = { ...a } as IActionDetails;
-                      if (action.type === 'forward') {
-                        action.targetGroup = (this.loadBalancer as IAmazonApplicationLoadBalancer).targetGroups.find(
-                          (tg) => tg.name === action.targetGroupName,
-                        );
-                      }
-                      return action;
-                    });
-                    this.listeners.push({ in: inMatch, actions });
-                  });
-                });
-              }
-
-              if (elb.ipAddressType === 'dualstack') {
-                this.ipAddressTypeDescription = 'IPv4 and IPv6';
-              }
-              if (elb.ipAddressType === 'ipv4') {
-                this.ipAddressTypeDescription = 'IPv4';
-              }
-            } else {
-              // Classic
-              const elb = details[0] as IClassicLoadBalancerSourceData;
-              if (elb.listenerDescriptions) {
-                this.elbProtocol = 'http:';
-                if (elb.listenerDescriptions.some((l: any) => l.listener.protocol === 'HTTPS')) {
-                  this.elbProtocol = 'https:';
-                }
-              }
-            }
-
-            (this.loadBalancer.elb.securityGroups || []).forEach((securityGroupId: string) => {
-              const match = this.securityGroupReader.getApplicationSecurityGroup(
-                this.app,
-                this.loadBalancerFromParams.accountId,
-                this.loadBalancerFromParams.region,
-                securityGroupId,
-              );
-              if (match) {
-                securityGroups.push(match);
-              }
-            });
-            this.securityGroups = sortBy(securityGroups, 'name');
-
-            if (this.loadBalancer.subnets) {
-              this.loadBalancer.subnetDetails = this.loadBalancer.subnets.reduce(
-                (subnetDetails: ISubnet[], subnetId: string) => {
-                  SubnetReader.getSubnetByIdAndProvider(subnetId, this.loadBalancer.provider).then(
-                    (subnetDetail: ISubnet) => {
-                      subnetDetails.push(subnetDetail);
-                    },
-                  );
-
-                  return subnetDetails;
-                },
-                [],
-              );
-            }
-          }
-        },
-        () => this.autoClose(),
-      );
-    } else {
-      this.autoClose();
-    }
-    if (!this.loadBalancer) {
-      this.autoClose();
-    }
-
-    return this.$q.when(null);
-  }
-
-  public getFirstSubnetPurpose(subnetDetailsList: ISubnet[] = []) {
-    return head(subnetDetailsList.map((subnet) => subnet.purpose)) || '';
-  }
-}
-
-export const AWS_LOAD_BALANCER_DETAILS_CTRL = 'spinnaker.amazon.loadBalancer.details.controller';
-module(AWS_LOAD_BALANCER_DETAILS_CTRL, [
-  UIROUTER_ANGULARJS,
-  SECURITY_GROUP_READER,
-  LOAD_BALANCER_ACTIONS,
-  LOAD_BALANCER_READ_SERVICE,
-  MANAGED_RESOURCE_DETAILS_INDICATOR,
-]).controller('awsLoadBalancerDetailsCtrl', AwsLoadBalancerDetailsController);