@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/instance/details/AmazonInstanceDetails.tsx

@@ -0,0 +1,644 @@
+import { flatMap } from 'lodash';
+import React from 'react';
+
+import type { Application, IInstanceDetailsProps, IRouterInjectedProps } from '@spinnaker/core';
+import {
+  CollapsibleSection,
+  ConfirmationModalService,
+  ConsoleOutputLink,
+  InstanceActions,
+  InstanceDetailsHeader,
+  InstanceInsights,
+  InstanceLinks,
+  InstanceReader,
+  RecentHistoryService,
+  SETTINGS,
+  withRouter,
+} from '@spinnaker/core';
+
+import { AmazonInstanceInformation } from './AmazonInstanceInformation';
+import { InstanceDns } from './InstanceDns';
+import { InstanceSecurityGroups } from './InstanceSecurityGroups';
+import { InstanceStatus } from './InstanceStatus';
+import { InstanceTags } from './InstanceTags';
+import { AmazonInstanceWriter } from '../amazon.instance.write.service';
+import { AWSProviderSettings } from '../../aws.settings';
+import type { IAmazonHealth, IAmazonInstance } from '../../domain';
+import { applyHealthCheckInfoToTargetGroups, getAllTargetGroups } from './utils';
+
+interface IAmazonInstanceParams {
+  account?: string;
+  instanceId: string;
+  provider?: string;
+  region?: string;
+}
+
+interface IAmazonInstanceDetailsProps extends Partial<IInstanceDetailsProps> {
+  accountId?: string;
+  app: Application;
+  environment?: string;
+  initialInstance?: IAmazonLoadedInstance;
+  instance?: IAmazonInstanceParams;
+  $stateParams?: IInstanceDetailsProps['$stateParams'] & Partial<IAmazonInstanceParams>;
+}
+
+interface IAmazonInstanceLookupResult {
+  account?: string;
+  extraData?: { [key: string]: string };
+  loadBalancers?: string[];
+  region?: string;
+  serverGroupDisabled?: boolean;
+  summary?: any;
+  targetGroups?: string[];
+  vpcId?: string;
+}
+
+export interface IAmazonLoadedInstance extends IAmazonInstance {
+  [key: string]: any;
+  baseIpAddress?: string;
+  healthMetrics?: IAmazonHealth[];
+  instanceId?: string;
+  instanceIdNotFound?: string;
+  ipv6Addresses?: Array<{ ip: string; url: string }>;
+  permanentIps?: string[];
+  serverGroupDisabled?: boolean;
+}
+
+function findInServerGroups(app: Application, instanceId: string): IAmazonInstanceLookupResult | undefined {
+  const serverGroups = app.serverGroups?.data || [];
+  for (const serverGroup of serverGroups) {
+    const summary = serverGroup.instances?.find((possibleInstance: any) => possibleInstance.id === instanceId);
+    if (summary) {
+      return {
+        account: serverGroup.account,
+        extraData: { serverGroup: serverGroup.name, vpcId: serverGroup.vpcId },
+        loadBalancers: serverGroup.loadBalancers,
+        region: serverGroup.region,
+        serverGroupDisabled: serverGroup.isDisabled,
+        summary,
+        targetGroups: serverGroup.targetGroups,
+        vpcId: serverGroup.vpcId,
+      };
+    }
+  }
+  return undefined;
+}
+
+function findInLoadBalancers(app: Application, instanceId: string): IAmazonInstanceLookupResult | undefined {
+  const loadBalancers = app.loadBalancers?.data || [];
+  for (const loadBalancer of loadBalancers) {
+    const summary = loadBalancer.instances?.find((possibleInstance: any) => possibleInstance.id === instanceId);
+    if (summary) {
+      return {
+        account: loadBalancer.account,
+        loadBalancers: [loadBalancer.name],
+        region: loadBalancer.region,
+        summary,
+        vpcId: loadBalancer.vpcId,
+      };
+    }
+
+    const targetGroup = loadBalancer.targetGroups?.find((candidate: any) =>
+      candidate.instances?.some((possibleInstance: any) => possibleInstance.id === instanceId),
+    );
+    if (targetGroup) {
+      const targetInstance = targetGroup.instances.find((possibleInstance: any) => possibleInstance.id === instanceId);
+      return {
+        account: loadBalancer.account,
+        region: loadBalancer.region,
+        summary: targetInstance,
+        targetGroups: [targetGroup.name],
+        vpcId: loadBalancer.vpcId,
+      };
+    }
+  }
+  return undefined;
+}
+
+function findInDisabledLoadBalancerServerGroups(
+  app: Application,
+  instanceId: string,
+): IAmazonInstanceLookupResult | undefined {
+  const loadBalancers = app.loadBalancers?.data || [];
+  for (const loadBalancer of loadBalancers) {
+    const disabledServerGroups = (loadBalancer.serverGroups || []).filter((serverGroup: any) => serverGroup.isDisabled);
+    for (const serverGroup of disabledServerGroups) {
+      const summary = serverGroup.instances?.find((possibleInstance: any) => possibleInstance.id === instanceId);
+      if (summary) {
+        return {
+          account: loadBalancer.account,
+          loadBalancers: [loadBalancer.name],
+          region: loadBalancer.region,
+          summary,
+          vpcId: loadBalancer.vpcId,
+        };
+      }
+    }
+
+    const targetGroup = loadBalancer.targetGroups?.find((candidate: any) =>
+      (candidate.serverGroups || []).some(
+        (serverGroup: any) =>
+          serverGroup.isDisabled &&
+          serverGroup.instances?.some((possibleInstance: any) => possibleInstance.id === instanceId),
+      ),
+    );
+    if (targetGroup) {
+      const serverGroup = targetGroup.serverGroups.find((candidate: any) =>
+        candidate.instances?.some((possibleInstance: any) => possibleInstance.id === instanceId),
+      );
+      const summary = serverGroup.instances.find((possibleInstance: any) => possibleInstance.id === instanceId);
+      return {
+        account: loadBalancer.account,
+        loadBalancers: [loadBalancer.name],
+        region: loadBalancer.region,
+        summary,
+        vpcId: loadBalancer.vpcId,
+      };
+    }
+  }
+  return undefined;
+}
+
+function findAmazonInstanceSummary(
+  app: Application,
+  instance: IAmazonInstanceParams,
+): IAmazonInstanceLookupResult | undefined {
+  if (!app.serverGroups) {
+    return {
+      account: instance.account,
+      loadBalancers: [],
+      region: instance.region,
+      summary: { id: instance.instanceId },
+    };
+  }
+
+  return (
+    findInServerGroups(app, instance.instanceId) ||
+    findInLoadBalancers(app, instance.instanceId) ||
+    findInDisabledLoadBalancerServerGroups(app, instance.instanceId)
+  );
+}
+
+function extractHealthMetrics(app: Application, summary: any, details: any, account: string): IAmazonHealth[] {
+  if (app.isStandalone) {
+    summary.health = details.health;
+  }
+
+  const displayableMetrics = ((summary.health || []) as IAmazonHealth[]).filter(
+    (metric) => metric.type !== 'Amazon' || metric.state !== 'Unknown',
+  );
+
+  if (!app.isStandalone) {
+    const targetGroups = getAllTargetGroups(
+      (app.loadBalancers?.data || []).filter((loadBalancer: any) => loadBalancer.cloudProvider === 'aws'),
+    );
+    applyHealthCheckInfoToTargetGroups(displayableMetrics, targetGroups, account);
+  }
+
+  (details.health || []).forEach((latest: IAmazonHealth) => {
+    const metric = displayableMetrics.find((candidate) => candidate.type === latest.type);
+    if (metric) {
+      Object.assign(metric, { ...latest, ...metric });
+    }
+  });
+
+  return displayableMetrics;
+}
+
+export async function loadAmazonInstanceDetails({
+  app,
+  instance,
+}: {
+  app: Application;
+  instance: IAmazonInstanceParams;
+}): Promise<IAmazonLoadedInstance> {
+  const lookup = findAmazonInstanceSummary(app, instance);
+
+  if (!lookup?.summary || !lookup.account || !lookup.region) {
+    return ({ instanceIdNotFound: instance.instanceId } as unknown) as IAmazonLoadedInstance;
+  }
+
+  RecentHistoryService.addExtraDataToLatest('instances', {
+    ...lookup.extraData,
+    account: lookup.account,
+    region: lookup.region,
+  });
+
+  const details = (await InstanceReader.getInstanceDetails(lookup.account, lookup.region, instance.instanceId)) as any;
+  const loadedInstance = {
+    ...lookup.summary,
+    ...details,
+    account: lookup.account,
+    baseIpAddress: details.publicDnsName || details.privateIpAddress,
+    healthMetrics: extractHealthMetrics(app, lookup.summary, details, lookup.account),
+    instanceId: details.instanceId || lookup.summary.instanceId || lookup.summary.id || instance.instanceId,
+    loadBalancers: lookup.loadBalancers,
+    region: lookup.region,
+    serverGroupDisabled: lookup.serverGroupDisabled,
+    targetGroups: lookup.targetGroups,
+    vpcId: lookup.vpcId,
+  } as IAmazonLoadedInstance;
+
+  if (lookup.extraData?.serverGroup) {
+    loadedInstance.serverGroup = lookup.extraData.serverGroup;
+  }
+
+  if (loadedInstance.networkInterfaces) {
+    const instancePort = app.attributes?.instancePort || SETTINGS.defaultInstancePort || 80;
+    loadedInstance.ipv6Addresses = flatMap(loadedInstance.networkInterfaces, (networkInterface: any) =>
+      (networkInterface.ipv6Addresses || []).map((address: any) => ({
+        ip: address.ipv6Address,
+        url: `http://${address.ipv6Address}:${instancePort}`,
+      })),
+    );
+    loadedInstance.permanentIps = loadedInstance.networkInterfaces
+      .filter((networkInterface: any) => networkInterface.attachment?.deleteOnTermination === false)
+      .map((networkInterface: any) => networkInterface.privateIpAddress);
+  }
+
+  return loadedInstance;
+}
+
+function hasHealthState(instance: IAmazonLoadedInstance, healthProviderType: string, state: string): boolean {
+  return (instance.health || []).some((health: any) => health.type === healthProviderType && health.state === state);
+}
+
+function canRegisterWithLoadBalancer(instance: IAmazonLoadedInstance): boolean {
+  if (!instance.loadBalancers?.length) {
+    return false;
+  }
+  return (
+    hasHealthState(instance, 'LoadBalancer', 'OutOfService') ||
+    !(instance.health || []).some((health: any) => health.type === 'LoadBalancer')
+  );
+}
+
+function canRegisterWithTargetGroup(instance: IAmazonLoadedInstance): boolean {
+  if (!instance.targetGroups?.length) {
+    return false;
+  }
+  return (
+    hasHealthState(instance, 'TargetGroup', 'OutOfService') ||
+    !(instance.health || []).some((health: any) => health.type === 'TargetGroup')
+  );
+}
+
+function canDeregisterFromTargetGroup(instance: IAmazonLoadedInstance): boolean {
+  return (instance.health || []).some(
+    (health: any) => health.type === 'TargetGroup' && health.state !== 'OutOfService',
+  );
+}
+
+export function AmazonInstanceActionsComponent({
+  app,
+  instance,
+  stateService,
+}: {
+  app: Application;
+  instance: IAmazonLoadedInstance;
+} & IRouterInjectedProps): JSX.Element | null {
+  if (!AWSProviderSettings.adHocInfraWritesEnabled) {
+    return null;
+  }
+
+  const closeIfCurrentInstance = () => {
+    if (stateService.includes('**.instanceDetails', { instanceId: instance.instanceId })) {
+      stateService.go('^');
+    }
+  };
+  const confirm = (
+    header: string,
+    buttonText: string,
+    title: string,
+    submitMethod: (params?: any) => PromiseLike<any>,
+    closeOnComplete = false,
+    extraConfig: any = {},
+  ) => {
+    ConfirmationModalService.confirm({
+      header,
+      buttonText,
+      account: instance.account,
+      taskMonitorConfig: {
+        application: app,
+        title,
+        onTaskComplete: closeOnComplete ? closeIfCurrentInstance : undefined,
+      },
+      submitMethod,
+      ...extraConfig,
+    });
+  };
+
+  const loadBalancerNames = (instance.loadBalancers || []).join(' and ');
+  const targetGroupNames = (instance.targetGroups || []).join(' and ');
+  const actions = [
+    {
+      label: 'Reboot',
+      triggerAction: () =>
+        confirm(
+          `Really reboot ${instance.instanceId}?`,
+          `Reboot ${instance.instanceId}`,
+          `Rebooting ${instance.instanceId}`,
+          (params = {}) => {
+            if (app.attributes?.platformHealthOnlyShowOverride && app.attributes?.platformHealthOnly) {
+              params.interestingHealthProviderNames = ['Amazon'];
+            }
+            return AmazonInstanceWriter.rebootInstance(instance, app, params);
+          },
+          false,
+          {
+            platformHealthOnlyShowOverride: app.attributes?.platformHealthOnlyShowOverride,
+            platformHealthType: 'Amazon',
+          },
+        ),
+    },
+    {
+      label: 'Terminate',
+      triggerAction: () =>
+        confirm(
+          `Really terminate ${instance.instanceId}?`,
+          `Terminate ${instance.instanceId}`,
+          `Terminating ${instance.instanceId}`,
+          () => AmazonInstanceWriter.terminateInstance(instance, app),
+          true,
+        ),
+    },
+  ];
+
+  if (instance.serverGroup) {
+    actions.push({
+      label: 'Terminate and Shrink Server Group',
+      triggerAction: () =>
+        confirm(
+          `Really terminate ${instance.instanceId} and shrink ${instance.serverGroup}?`,
+          `Terminate ${instance.instanceId} and shrink ${instance.serverGroup}`,
+          `Terminating ${instance.instanceId} and shrinking server group`,
+          () => AmazonInstanceWriter.terminateInstanceAndShrinkServerGroup(instance, app),
+          true,
+        ),
+    });
+  }
+
+  if (hasHealthState(instance, 'Discovery', 'OutOfService') && !instance.serverGroupDisabled) {
+    actions.unshift({
+      label: 'Enable In Discovery',
+      triggerAction: () =>
+        confirm(
+          `Really enable ${instance.instanceId} in discovery?`,
+          `Enable ${instance.instanceId}`,
+          `Enabling ${instance.instanceId} in discovery`,
+          () => AmazonInstanceWriter.enableInstanceInDiscovery(instance, app),
+        ),
+    });
+  }
+
+  if (hasHealthState(instance, 'Discovery', 'Up') || hasHealthState(instance, 'Discovery', 'Down')) {
+    actions.unshift({
+      label: 'Disable in Discovery',
+      triggerAction: () =>
+        confirm(
+          `Really disable ${instance.instanceId} in discovery?`,
+          `Disable ${instance.instanceId}`,
+          `Disabling ${instance.instanceId} in discovery`,
+          () => AmazonInstanceWriter.disableInstanceInDiscovery(instance, app),
+        ),
+    });
+  }
+
+  if (canRegisterWithLoadBalancer(instance)) {
+    actions.unshift({
+      label: 'Register with Load Balancer',
+      triggerAction: () =>
+        confirm(
+          `Really register ${instance.instanceId} with ${loadBalancerNames}?`,
+          `Register ${instance.instanceId}`,
+          `Registering ${instance.instanceId} with ${loadBalancerNames}`,
+          () => AmazonInstanceWriter.registerInstanceWithLoadBalancer(instance, app),
+        ),
+    });
+  }
+
+  if ((instance.health || []).some((health: any) => health.type === 'LoadBalancer')) {
+    actions.unshift({
+      label: 'Deregister from Load Balancer',
+      triggerAction: () =>
+        confirm(
+          `Really deregister ${instance.instanceId} from ${loadBalancerNames}?`,
+          `Deregister ${instance.instanceId}`,
+          `Deregistering ${instance.instanceId} from ${loadBalancerNames}`,
+          () => AmazonInstanceWriter.deregisterInstanceFromLoadBalancer(instance, app),
+        ),
+    });
+  }
+
+  if (canRegisterWithTargetGroup(instance)) {
+    actions.unshift({
+      label: 'Register with Target Group',
+      triggerAction: () =>
+        confirm(
+          `Really register ${instance.instanceId} with ${targetGroupNames}?`,
+          `Register ${instance.instanceId}`,
+          `Registering ${instance.instanceId} with ${targetGroupNames}`,
+          () => AmazonInstanceWriter.registerInstanceWithTargetGroup(instance, app),
+        ),
+    });
+  }
+
+  if (canDeregisterFromTargetGroup(instance)) {
+    actions.unshift({
+      label: 'Deregister from Target Group',
+      triggerAction: () =>
+        confirm(
+          `Really deregister ${instance.instanceId} from ${targetGroupNames}?`,
+          `Deregister ${instance.instanceId}`,
+          `Deregistering ${instance.instanceId} from ${targetGroupNames}`,
+          () => AmazonInstanceWriter.deregisterInstanceFromTargetGroup(instance, app),
+        ),
+    });
+  }
+
+  return <InstanceActions actions={actions} />;
+}
+
+export class AmazonInstanceDetailsComponent extends React.Component<
+  IAmazonInstanceDetailsProps & IRouterInjectedProps,
+  { instance?: IAmazonLoadedInstance; loading: boolean }
+> {
+  public state = { instance: this.props.initialInstance, loading: !this.props.initialInstance };
+
+  private activeRequestId = 0;
+  private isUnmounted = false;
+  private unsubscribeFromRefresh: () => void;
+
+  public componentDidMount(): void {
+    if (this.props.initialInstance) {
+      return;
+    }
+
+    const { app } = this.props;
+    const retrieveWhenReady = app.isStandalone
+      ? Promise.resolve()
+      : Promise.all([app.serverGroups.ready(), app.loadBalancers.ready()]);
+    retrieveWhenReady
+      .then(() => {
+        if (this.isUnmounted) {
+          return;
+        }
+        this.retrieveInstance();
+        if (!app.isStandalone && app.serverGroups?.onRefresh) {
+          this.unsubscribeFromRefresh = app.serverGroups.onRefresh(this.retrieveInstance);
+        }
+      })
+      .catch(() => {
+        if (!this.isUnmounted) {
+          this.closeDetails();
+        }
+      });
+  }
+
+  private closeDetails(): void {
+    this.props.stateService.go('^', { allowModalToStayOpen: true }, { location: 'replace' });
+  }
+
+  public componentDidUpdate(prevProps: IAmazonInstanceDetailsProps): void {
+    const previousParams = this.getInstanceParams(prevProps);
+    const currentParams = this.getInstanceParams();
+    if (
+      previousParams.account !== currentParams.account ||
+      previousParams.instanceId !== currentParams.instanceId ||
+      previousParams.region !== currentParams.region
+    ) {
+      this.retrieveInstance(true);
+    }
+  }
+
+  public componentWillUnmount(): void {
+    this.isUnmounted = true;
+    if (this.unsubscribeFromRefresh) {
+      this.unsubscribeFromRefresh();
+    }
+  }
+
+  private getInstanceParams(
+    props: IAmazonInstanceDetailsProps & Partial<IRouterInjectedProps> = this.props,
+  ): IAmazonInstanceParams {
+    const params = props.instance || props.$stateParams || props.stateParams;
+    return {
+      account: params?.account,
+      instanceId: params?.instanceId,
+      provider: params?.provider,
+      region: params?.region,
+    };
+  }
+
+  private retrieveInstance = (clearInstance = false): void => {
+    const requestId = ++this.activeRequestId;
+    this.setState(clearInstance ? { instance: undefined, loading: true } : { loading: true });
+    loadAmazonInstanceDetails({ app: this.props.app, instance: this.getInstanceParams() }).then(
+      (instance) => {
+        if (!this.isUnmounted && requestId === this.activeRequestId) {
+          this.setState({ instance, loading: false });
+        }
+      },
+      () => {
+        if (!this.isUnmounted && requestId === this.activeRequestId) {
+          if (this.props.app.isStandalone) {
+            RecentHistoryService.removeLastItem('instances');
+            this.setState({
+              instance: ({
+                instanceIdNotFound: this.getInstanceParams().instanceId,
+              } as unknown) as IAmazonLoadedInstance,
+              loading: false,
+            });
+          } else {
+            this.closeDetails();
+          }
+        }
+      },
+    );
+  };
+
+  public render(): JSX.Element {
+    const { app, environment, moniker } = this.props;
+    const { instance, loading } = this.state;
+    const instanceId = instance?.instanceId || instance?.instanceIdNotFound || this.getInstanceParams().instanceId;
+    const instancePort = app.attributes?.instancePort || SETTINGS.defaultInstancePort || 80;
+
+    return (
+      <div className="details-panel">
+        <div className="header">
+          <InstanceDetailsHeader
+            cloudProvider="aws"
+            healthState={instance?.healthState}
+            instanceId={instanceId}
+            loading={loading}
+            standalone={app.isStandalone}
+          />
+          {!loading && instance && !instance.instanceIdNotFound && instance.placement && (
+            <div className="actions">
+              <AmazonInstanceActionsComponent
+                app={app}
+                instance={instance}
+                router={this.props.router}
+                stateParams={this.props.stateParams}
+                stateService={this.props.stateService}
+              />
+              <InstanceInsights insights={instance.insightActions} instance={instance} />
+            </div>
+          )}
+        </div>
+        {!loading && instance && !instance.instanceIdNotFound && (
+          <div className="content">
+            <AmazonInstanceInformation instance={instance} />
+            <InstanceStatus
+              healthMetrics={instance.healthMetrics || []}
+              healthState={instance.healthState}
+              metricTypes={['LoadBalancer', 'TargetGroup']}
+              privateIpAddress={instance.privateIpAddress}
+            />
+            <CollapsibleSection heading="DNS">
+              <InstanceDns
+                instancePort={String(instance.instancePort || instancePort)}
+                ipv6Addresses={instance.ipv6Addresses || []}
+                permanentIps={instance.permanentIps || []}
+                privateDnsName={instance.privateDnsName || ''}
+                privateIpAddress={instance.privateIpAddress || ''}
+                publicDnsName={instance.publicDnsName || ''}
+                publicIpAddress={instance.publicIpAddress || ''}
+              />
+            </CollapsibleSection>
+            <InstanceSecurityGroups instance={instance} />
+            <InstanceTags tags={instance.tags || []} />
+            {instance.baseIpAddress && (
+              <CollapsibleSection heading="Console Output">
+                <ul>
+                  <li>
+                    <ConsoleOutputLink instance={instance} />
+                  </li>
+                </ul>
+              </CollapsibleSection>
+            )}
+            <InstanceLinks
+              address={instance.baseIpAddress}
+              application={app}
+              instance={instance}
+              moniker={moniker}
+              environment={environment}
+            />
+          </div>
+        )}
+        {!loading && instance?.instanceIdNotFound && (
+          <div className="content">
+            <div className="content-section">
+              <div className="content-body text-center">
+                <h3>Instance not found.</h3>
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    );
+  }
+}
+
+export const AmazonInstanceActions = withRouter(AmazonInstanceActionsComponent);
+export const AmazonInstanceDetails = withRouter(AmazonInstanceDetailsComponent);

package/src/instance/details/InstanceInformation.tsx

@@ -1,5 +1,4 @@
 import { UISref } from '@uirouter/react';
-import { UIRouterContextComponent } from '@uirouter/react-hybrid';
 import React from 'react';
 
 import { AccountTag, LabeledValue, timestamp } from '@spinnaker/core';
@@ -45,19 +44,17 @@ export const InstanceInformation = ({
         label="Server Group"
         value={
           <div>
-            <UIRouterContextComponent>
-              <UISref
-                to="^.serverGroup"
-                params={{
-                  region,
-                  accountId: account,
-                  serverGroup,
-                  provider,
-                }}
-              >
-                <a>{serverGroup}</a>
-              </UISref>
-            </UIRouterContextComponent>
+            <UISref
+              to="^.serverGroup"
+              params={{
+                region,
+                accountId: account,
+                serverGroup,
+                provider,
+              }}
+            >
+              <a>{serverGroup}</a>
+            </UISref>
           </div>
         }
       />