@spinnaker/amazon 0.0.0-2025.1-0

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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,65 @@
+<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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,13 @@
+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/instance/details/utils.ts

@@ -0,0 +1,34 @@
+import { flatten, isNil } from 'lodash';
+
+import type {
+  IAmazonApplicationLoadBalancer,
+  IAmazonHealth,
+  IAmazonNetworkLoadBalancer,
+  ITargetGroup,
+} from '../../domain';
+
+export const getAllTargetGroups = (
+  loadBalancers: IAmazonApplicationLoadBalancer[] | IAmazonNetworkLoadBalancer[],
+): ITargetGroup[] => {
+  const allTargetGroups = loadBalancers.map((d) => d.targetGroups);
+  const targetGroups = flatten(allTargetGroups);
+  return targetGroups;
+};
+
+export const applyHealthCheckInfoToTargetGroups = (
+  healthMetrics: IAmazonHealth[],
+  targetGroups: ITargetGroup[],
+  account: string,
+) => {
+  healthMetrics.forEach((metric) => {
+    if (metric.type === 'TargetGroup') {
+      metric.targetGroups.forEach((tg) => {
+        const group = targetGroups.find((g) => g.name === tg.name && g.account === account) ?? ({} as ITargetGroup);
+        const useTrafficPort = group.healthCheckPort === 'traffic-port' || isNil(group.healthCheckPort);
+        const port = useTrafficPort ? group.port : group.healthCheckPort;
+        tg.healthCheckProtocol = group.healthCheckProtocol?.toLowerCase();
+        tg.healthCheckPath = `:${port}${group.healthCheckPath ?? ''}`;
+      });
+    }
+  });
+};

package/src/instance/index.ts

@@ -0,0 +1,5 @@
+export * from './details/utils';
+export * from './details/InstanceDns';
+export * from './details/InstanceInformation';
+export * from './details/InstanceStatus';
+export * from './amazon.instance.write.service';

package/src/keyPairs/KeyPairsReader.ts

@@ -0,0 +1,11 @@
+import { REST } from '@spinnaker/core';
+import type { IKeyPair } from '../domain';
+
+export class KeyPairsReader {
+  public static listKeyPairs(): PromiseLike<IKeyPair[]> {
+    return REST('/keyPairs')
+      .useCache()
+      .get()
+      .then((keyPairs: IKeyPair[]) => keyPairs.sort((a, b) => a.keyName.localeCompare(b.keyName)));
+  }
+}

package/src/keyPairs/index.ts

@@ -0,0 +1 @@
+export * from './KeyPairsReader';

package/src/loadBalancer/AmazonLoadBalancerClusterContainer.tsx

@@ -0,0 +1,53 @@
+import { isEqual } from 'lodash';
+import React from 'react';
+
+import type { ILoadBalancerClusterContainerProps } from '@spinnaker/core';
+import { LoadBalancerClusterContainer } from '@spinnaker/core';
+
+import { TargetGroup } from './TargetGroup';
+import type { IAmazonApplicationLoadBalancer } from '../domain/IAmazonLoadBalancer';
+
+export class AmazonLoadBalancerClusterContainer extends React.Component<ILoadBalancerClusterContainerProps> {
+  public shouldComponentUpdate(nextProps: ILoadBalancerClusterContainerProps) {
+    const serverGroupsDiffer = () =>
+      !isEqual(
+        (nextProps.serverGroups || []).map((g) => g.name),
+        (this.props.serverGroups || []).map((g) => g.name),
+      );
+    const targetGroupsDiffer = () =>
+      !isEqual(
+        ((nextProps.loadBalancer as IAmazonApplicationLoadBalancer).targetGroups || []).map((t) => t.name),
+        ((this.props.loadBalancer as IAmazonApplicationLoadBalancer).targetGroups || []).map((t) => t.name),
+      );
+    return (
+      nextProps.showInstances !== this.props.showInstances ||
+      nextProps.showServerGroups !== this.props.showServerGroups ||
+      nextProps.loadBalancer !== this.props.loadBalancer ||
+      serverGroupsDiffer() ||
+      targetGroupsDiffer()
+    );
+  }
+
+  public render(): React.ReactElement<AmazonLoadBalancerClusterContainer> {
+    const { loadBalancer, showInstances, showServerGroups } = this.props;
+
+    if (loadBalancer.loadBalancerType !== 'classic') {
+      const alb = loadBalancer as IAmazonApplicationLoadBalancer;
+      const TargetGroups = alb.targetGroups.map((targetGroup) => {
+        return (
+          <TargetGroup
+            key={targetGroup.name}
+            loadBalancer={loadBalancer as IAmazonApplicationLoadBalancer}
+            targetGroup={targetGroup}
+            showInstances={showInstances}
+            showServerGroups={showServerGroups}
+          />
+        );
+      });
+      return <div className="cluster-container">{TargetGroups}</div>;
+    } else {
+      // Classic load balancer
+      return <LoadBalancerClusterContainer {...this.props} />;
+    }
+  }
+}

package/src/loadBalancer/AmazonLoadBalancersTag.tsx

@@ -0,0 +1,231 @@
+// This is all mercilessly copied from LoadBalancersTag.tsx. This should be cleaned up at some point
+// Probably when we convert clusters view to React.
+
+import { sortBy } from 'lodash';
+import React from 'react';
+
+import type { ILoadBalancer, ILoadBalancersTagProps } from '@spinnaker/core';
+import {
+  HealthCounts,
+  HoverablePopover,
+  LoadBalancerDataUtils,
+  logger,
+  ReactInjector,
+  Spinner,
+  Tooltip,
+} from '@spinnaker/core';
+
+import { AmazonLoadBalancerDataUtils } from './amazonLoadBalancerDataUtils';
+import type { IAmazonServerGroup, ITargetGroup } from '../domain';
+
+interface ILoadBalancerListItemProps {
+  loadBalancer: ILoadBalancer | ITargetGroup;
+  onItemClick: (loadBalancer: ILoadBalancer | ITargetGroup) => void;
+}
+
+interface ILoadBalancerSingleItemProps extends ILoadBalancerListItemProps {
+  label: string;
+}
+
+class LoadBalancerListItem extends React.Component<ILoadBalancerListItemProps> {
+  private onClick = (e: React.MouseEvent<HTMLElement>): void => {
+    this.props.onItemClick(this.props.loadBalancer);
+    e.nativeEvent.preventDefault(); // yay angular JQueryEvent still listening to the click event...
+  };
+
+  public render(): React.ReactElement<LoadBalancerListItem> {
+    return (
+      <a onClick={this.onClick}>
+        <span className="name">{this.props.loadBalancer.name}</span>
+        <HealthCounts container={this.props.loadBalancer.instanceCounts} />
+      </a>
+    );
+  }
+}
+
+class LoadBalancerButton extends React.Component<ILoadBalancerSingleItemProps> {
+  private onClick = (e: React.MouseEvent<HTMLElement>): void => {
+    this.props.onItemClick(this.props.loadBalancer);
+    e.nativeEvent.preventDefault(); // yay angular JQueryEvent still listening to the click event...
+  };
+
+  public render(): React.ReactElement<LoadBalancerButton> {
+    return (
+      <Tooltip value={`${this.props.label || 'Load Balancer'}: ${this.props.loadBalancer.name}`}>
+        <button className="btn btn-link no-padding" onClick={this.onClick}>
+          <span className="badge badge-counter">
+            <span className="icon">
+              <i className="fa icon-sitemap" />
+            </span>
+          </span>
+        </button>
+      </Tooltip>
+    );
+  }
+}
+
+export interface IAmazonLoadBalancersTagState {
+  loadBalancers: ILoadBalancer[];
+  targetGroups: ITargetGroup[];
+  isLoading: boolean;
+}
+
+export class AmazonLoadBalancersTag extends React.Component<ILoadBalancersTagProps, IAmazonLoadBalancersTagState> {
+  private loadBalancersRefreshUnsubscribe: () => void;
+  private mounted = false;
+
+  constructor(props: ILoadBalancersTagProps) {
+    super(props);
+    this.state = {
+      loadBalancers: [],
+      targetGroups: [],
+      isLoading: true,
+    };
+  }
+
+  private showLoadBalancerDetails = (loadBalancer: ILoadBalancer): void => {
+    const { $state } = ReactInjector;
+    const serverGroup = this.props.serverGroup;
+    logger.log({ category: 'Cluster Pod', action: `Load Load Balancer Details (multiple menu)` });
+    const nextState = $state.current.name.endsWith('.clusters') ? '.loadBalancerDetails' : '^.loadBalancerDetails';
+    $state.go(nextState, {
+      region: serverGroup.region,
+      accountId: serverGroup.account,
+      name: loadBalancer.name,
+      provider: serverGroup.type,
+    });
+  };
+
+  private showTargetGroupDetails = (targetGroup: ITargetGroup): void => {
+    const { $state } = ReactInjector;
+    logger.log({ category: 'Cluster Pod', action: `Load Target Group Details (multiple menu)` });
+    const nextState = $state.current.name.endsWith('.clusters') ? '.targetGroupDetails' : '^.targetGroupDetails';
+    $state.go(nextState, {
+      region: targetGroup.region,
+      accountId: targetGroup.account,
+      name: targetGroup.name,
+      provider: 'aws',
+      loadBalancerName: targetGroup.loadBalancerNames[0],
+    });
+  };
+
+  private handleShowPopover = () => {
+    logger.log({ category: 'Cluster Pod', action: `Show Load Balancers Menu` });
+  };
+
+  private handleClick = (e: React.MouseEvent<HTMLElement>): void => {
+    e.preventDefault();
+    e.stopPropagation();
+  };
+
+  public componentDidMount(): void {
+    this.mounted = true;
+    this.loadBalancersRefreshUnsubscribe = this.props.application.getDataSource('loadBalancers').onRefresh(null, () => {
+      this.forceUpdate();
+    });
+
+    LoadBalancerDataUtils.populateLoadBalancers(this.props.application, this.props.serverGroup).then(
+      (loadBalancers) => {
+        if (this.mounted) {
+          this.setState({ loadBalancers, isLoading: false });
+        }
+      },
+    );
+    AmazonLoadBalancerDataUtils.populateTargetGroups(
+      this.props.application,
+      this.props.serverGroup as IAmazonServerGroup,
+    ).then((targetGroups: ITargetGroup[]) => {
+      if (this.mounted) {
+        this.setState({ targetGroups });
+      }
+    });
+  }
+
+  public componentWillUnmount(): void {
+    this.mounted = false;
+    this.loadBalancersRefreshUnsubscribe();
+  }
+
+  public render(): React.ReactElement<AmazonLoadBalancersTag> {
+    const { loadBalancers, targetGroups, isLoading } = this.state;
+
+    const targetGroupCount = (targetGroups && targetGroups.length) || 0;
+    const loadBalancerCount = (loadBalancers && loadBalancers.length) || 0;
+    const totalCount = targetGroupCount + loadBalancerCount;
+
+    if (!totalCount) {
+      return isLoading ? <Spinner size="nano" /> : null;
+    }
+
+    const className = `load-balancers-tag ${totalCount > 1 ? 'overflowing' : ''}`;
+    const popover = (
+      <div className="menu-load-balancers">
+        {loadBalancerCount > 0 && <div className="menu-load-balancers-header">Load Balancers</div>}
+        {sortBy(loadBalancers, 'name').map((loadBalancer) => (
+          <LoadBalancerListItem
+            key={loadBalancer.name}
+            loadBalancer={loadBalancer}
+            onItemClick={this.showLoadBalancerDetails}
+          />
+        ))}
+
+        {targetGroupCount > 0 && <div className="menu-load-balancers-header">Target Groups</div>}
+        {sortBy(targetGroups, 'name').map((targetGroup) => (
+          <LoadBalancerListItem
+            key={targetGroup.name}
+            loadBalancer={targetGroup}
+            onItemClick={this.showTargetGroupDetails}
+          />
+        ))}
+      </div>
+    );
+
+    return (
+      <span className={className}>
+        {totalCount > 1 && (
+          <HoverablePopover
+            delayShow={100}
+            delayHide={150}
+            onShow={this.handleShowPopover}
+            placement="bottom"
+            template={popover}
+            hOffsetPercent="80%"
+            container={this.props.container}
+            className="no-padding menu-load-balancers"
+          >
+            <button onClick={this.handleClick} className="btn btn-link btn-multiple-load-balancers clearfix no-padding">
+              <span className="badge badge-counter">
+                <span className="icon">
+                  <i className="fa icon-sitemap" />
+                </span>{' '}
+                {totalCount}
+              </span>
+            </button>
+          </HoverablePopover>
+        )}
+
+        {loadBalancers.length === 1 && targetGroups.length === 0 && (
+          <span className="btn-load-balancer">
+            <LoadBalancerButton
+              key={loadBalancers[0].name}
+              label="Load Balancer"
+              loadBalancer={loadBalancers[0]}
+              onItemClick={this.showLoadBalancerDetails}
+            />
+          </span>
+        )}
+
+        {targetGroups.length === 1 && loadBalancers.length === 0 && (
+          <span className="btn-load-balancer">
+            <LoadBalancerButton
+              key={targetGroups[0].name}
+              label="Target Group"
+              loadBalancer={targetGroups[0]}
+              onItemClick={this.showTargetGroupDetails}
+            />
+          </span>
+        )}
+      </span>
+    );
+  }
+}

package/src/loadBalancer/OidcConfigReader.ts

@@ -0,0 +1,21 @@
+import { REST } from '@spinnaker/core';
+
+export interface IAuthenticateOidcActionConfig {
+  authorizationEndpoint: string;
+  authenticationRequestExtraParams?: any;
+  clientId: string;
+  clientSecret?: string;
+  idpLogoutUrl?: string;
+  issuer: string;
+  scope: string;
+  sessionCookieName: string;
+  sessionTimeout?: number;
+  tokenEndpoint: string;
+  userInfoEndpoint: string;
+}
+
+export class OidcConfigReader {
+  public static getOidcConfigsByApp(app: string): PromiseLike<IAuthenticateOidcActionConfig[]> {
+    return REST('/oidcConfigs').query({ app }).get();
+  }
+}