@spinnaker/amazon 0.0.0-2025.1-0

package/src/instance/awsInstanceTypes.ts

@@ -0,0 +1,311 @@
+import type { IInstanceTypeCategory, IInstanceTypeFamily, IPreferredInstanceType } from '@spinnaker/core';
+
+import { AWSProviderSettings } from '../aws.settings';
+
+interface IAwsInstanceTypeFamily extends IInstanceTypeFamily {
+  instanceTypes: IAwsPreferredInstanceType[];
+}
+
+interface IAwsPreferredInstanceType extends IPreferredInstanceType {
+  cpuCreditsPerHour?: number;
+}
+
+interface IAwsInstanceTypeCategory extends IInstanceTypeCategory {
+  showCpuCredits?: boolean;
+  descriptionListOverride?: string[];
+}
+
+const m5: IAwsInstanceTypeFamily = {
+  type: 'm5',
+  description:
+    'm5 instances provide a balance of compute, memory, and network resources. They are a good choice for most applications.',
+  instanceTypes: [
+    {
+      name: 'm5.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 8,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+    },
+    {
+      name: 'm5.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+    },
+    {
+      name: 'm5.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 4,
+    },
+  ],
+};
+
+const t2gp: IAwsInstanceTypeFamily = {
+  type: 't2',
+  description:
+    't2 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't2.small',
+      label: 'Small',
+      cpu: 1,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 12,
+    },
+    {
+      name: 't2.medium',
+      label: 'Medium',
+      cpu: 2,
+      memory: 4,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+    {
+      name: 't2.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 8,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+      cpuCreditsPerHour: 36,
+    },
+    {
+      name: 't2.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+      cpuCreditsPerHour: 54,
+    },
+    {
+      name: 't2.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 4,
+      cpuCreditsPerHour: 81,
+    },
+  ],
+};
+
+const t3gp: IAwsInstanceTypeFamily = {
+  type: 't3',
+  description:
+    't3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't3.small',
+      label: 'Small',
+      cpu: 2,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+    {
+      name: 't3.medium',
+      label: 'Medium',
+      cpu: 2,
+      memory: 4,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+    {
+      name: 't3.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 8,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+      cpuCreditsPerHour: 36,
+    },
+    {
+      name: 't3.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+      cpuCreditsPerHour: 96,
+    },
+    {
+      name: 't3.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 4,
+      cpuCreditsPerHour: 192,
+    },
+  ],
+};
+
+const t2: IAwsInstanceTypeFamily = {
+  type: 't2',
+  description:
+    't2 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't2.nano',
+      label: 'Nano',
+      cpu: 1,
+      memory: 0.5,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 3,
+    },
+    {
+      name: 't2.micro',
+      label: 'Micro',
+      cpu: 1,
+      memory: 1,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 6,
+    },
+    {
+      name: 't2.small',
+      label: 'Small',
+      cpu: 1,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 12,
+    },
+  ],
+};
+
+const t3: IAwsInstanceTypeFamily = {
+  type: 't3',
+  description:
+    't3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't3.nano',
+      label: 'Nano',
+      cpu: 2,
+      memory: 0.5,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 6,
+    },
+    {
+      name: 't3.micro',
+      label: 'Micro',
+      cpu: 2,
+      memory: 1,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 12,
+    },
+    {
+      name: 't3.small',
+      label: 'Small',
+      cpu: 2,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+  ],
+};
+
+const r5: IAwsInstanceTypeFamily = {
+  type: 'r5',
+  description:
+    'r5 instances are optimized for memory-intensive applications and have the lowest cost per GiB of RAM among Amazon EC2 instance types.',
+  instanceTypes: [
+    {
+      name: 'r5.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+    },
+    {
+      name: 'r5.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+    },
+    {
+      name: 'r5.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 64,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+    },
+    {
+      name: 'r5.4xlarge',
+      label: '4XLarge',
+      cpu: 16,
+      memory: 128,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+    },
+  ],
+};
+
+export const defaultCategories: IAwsInstanceTypeCategory[] = [
+  {
+    type: 'general',
+    label: 'General Purpose',
+    families: [m5, t2gp, t3gp],
+    icon: 'hdd',
+    showCpuCredits: true,
+    descriptionListOverride: [
+      m5.description,
+      't2/t3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+    ],
+  },
+  {
+    type: 'memory',
+    label: 'High Memory',
+    families: [r5],
+    icon: 'hdd',
+  },
+  {
+    type: 'micro',
+    label: 'Micro Utility',
+    families: [t2, t3],
+    icon: 'hdd',
+    showCpuCredits: true,
+    descriptionListOverride: [
+      't2/t3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+    ],
+  },
+  {
+    type: 'custom',
+    label: 'Custom Type',
+    families: [],
+    icon: 'asterisk',
+  },
+];
+
+const excludeCategories = AWSProviderSettings.instanceTypes?.exclude?.categories ?? [];
+const excludeFamilies = AWSProviderSettings.instanceTypes?.exclude?.families ?? [];
+
+export const categories = defaultCategories
+  .filter(({ type }) => !excludeCategories.includes(type))
+  .map((category) =>
+    Object.assign({}, category, {
+      families: category.families.filter(({ type }) => !excludeFamilies.includes(type)),
+    }),
+  );

package/src/instance/details/AmazonInstanceInformation.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+
+import { CollapsibleSection, LabeledValue, SubnetTag } from '@spinnaker/core';
+
+import { InstanceInformation } from './InstanceInformation';
+import type { IAmazonInstance } from '../../domain';
+import { VpcTag } from '../../vpc/VpcTag';
+
+export interface IAmazonInstanceInformationProps {
+  instance: IAmazonInstance;
+}
+
+export const AmazonInstanceInformation = ({ instance }: IAmazonInstanceInformationProps) => {
+  const { imageId, serverGroup, subnetId, vpcId } = instance;
+  return (
+    <CollapsibleSection heading="Instance Information" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <InstanceInformation
+          account={instance.account}
+          availabilityZone={instance.availabilityZone}
+          instanceType={instance.instanceType}
+          capacityType={instance.capacityType}
+          launchTime={instance.launchTime}
+          provider={instance.provider}
+          region={instance.region}
+          serverGroup={instance.serverGroup}
+          showInstanceType={true}
+        />
+        {serverGroup && <LabeledValue label="VPC" value={<VpcTag vpcId={vpcId} />} />}
+        {subnetId && <LabeledValue label="Subnet" value={<SubnetTag subnetId={subnetId} />} />}
+        {imageId && <LabeledValue label="Image ID" value={imageId} />}
+      </dl>
+    </CollapsibleSection>
+  );
+};

package/src/instance/details/CostFactor.tsx

@@ -0,0 +1,29 @@
+import React from 'react';
+
+export interface ICostFactorProps {
+  min: number;
+  max?: number;
+}
+
+export const CostFactor = ({ min, max }: ICostFactorProps) => {
+  const MAX_DOLLARS = 4;
+  const minDollars = (
+    <>
+      <span className="cost">{'$'.repeat(min)}</span>
+      {'$'.repeat(MAX_DOLLARS - min)}
+    </>
+  );
+  const maxDollars = (
+    <>
+      <span className="cost">{'$'.repeat(Math.min(MAX_DOLLARS, max))}</span>
+      {'$'.repeat(MAX_DOLLARS - Math.min(MAX_DOLLARS, max))}
+    </>
+  );
+
+  return (
+    <span className={'cost-factor'}>
+      {minDollars}
+      {max ? ` - ${maxDollars}` : ''}
+    </span>
+  );
+};

package/src/instance/details/InstanceDns.tsx

@@ -0,0 +1,73 @@
+import * as React from 'react';
+import { LabeledValue, LabeledValueList, LinkWithClipboard } from '@spinnaker/core';
+
+interface IIpv6Address {
+  ip: string;
+  url: string;
+}
+
+export interface IInstanceDnsProps {
+  instancePort: string;
+  ipv6Addresses: IIpv6Address[];
+  permanentIps: string[];
+  privateDnsName: string;
+  privateIpAddress: string;
+  publicDnsName: string;
+  publicIpAddress: string;
+}
+
+export const InstanceDns = ({
+  instancePort,
+  ipv6Addresses,
+  permanentIps,
+  privateDnsName,
+  privateIpAddress,
+  publicDnsName,
+  publicIpAddress,
+}: IInstanceDnsProps) => {
+  const portSuffix = instancePort ? `:${instancePort}` : '';
+  return (
+    <LabeledValueList className="horizontal-when-filters-collapsed">
+      {privateDnsName && (
+        <LabeledValue
+          label="Private DNS Name"
+          value={<LinkWithClipboard text={privateDnsName} url={`http://${privateDnsName}${portSuffix}`} />}
+        />
+      )}
+      {publicDnsName && (
+        <LabeledValue
+          label="Public DNS Name"
+          value={<LinkWithClipboard text={publicDnsName} url={`http://${publicDnsName}${portSuffix}`} />}
+        />
+      )}
+      {privateIpAddress && (
+        <LabeledValue
+          label="Private IP Address"
+          value={<LinkWithClipboard text={privateIpAddress} url={`http://${privateIpAddress}${portSuffix}`} />}
+        />
+      )}
+      {Boolean(permanentIps?.length) && (
+        <LabeledValue
+          label="Permanent IP Address"
+          value={permanentIps.map((ip) => (
+            <LinkWithClipboard key={ip} text={ip} url={`http://${ip}${portSuffix}`} />
+          ))}
+        />
+      )}
+      {publicIpAddress && (
+        <LabeledValue
+          label="Public IP Address"
+          value={<LinkWithClipboard text={publicIpAddress} url={`http://${publicIpAddress}${portSuffix}`} />}
+        />
+      )}
+      {Boolean(ipv6Addresses?.length) && (
+        <LabeledValue
+          label={`IPv6 Address${ipv6Addresses.length > 1 ? 'es' : ''}`}
+          value={ipv6Addresses.map((ipv6) => (
+            <LinkWithClipboard key={ipv6.ip} text={ipv6.ip} url={ipv6.url} />
+          ))}
+        />
+      )}
+    </LabeledValueList>
+  );
+};

package/src/instance/details/InstanceInformation.spec.tsx

@@ -0,0 +1,71 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { mockInstance } from '@spinnaker/mocks';
+
+import { InstanceInformation } from './InstanceInformation';
+
+describe('InstanceInformation', () => {
+  const testInstance = {
+    ...mockInstance,
+    instanceType: 'm5.large',
+    capacityType: 'spot',
+    region: 'us-east-1',
+    serverGroup: 'test_sg',
+  };
+
+  it('should render correct state when all attributes exist', () => {
+    const wrapper = shallow(
+      <InstanceInformation
+        account={testInstance.account}
+        availabilityZone={testInstance.availabilityZone}
+        instanceType={testInstance.instanceType}
+        capacityType={testInstance.capacityType}
+        launchTime={testInstance.launchTime}
+        provider={testInstance.provider}
+        region={testInstance.region}
+        serverGroup={testInstance.serverGroup}
+        showInstanceType={true}
+      />,
+    );
+
+    const labeledValues = wrapper.find('LabeledValue');
+    expect(labeledValues.length).toEqual(5);
+
+    expect(wrapper.childAt(0).prop('label')).toEqual('Launched');
+    expect(wrapper.childAt(1).prop('label')).toEqual('In');
+    expect(wrapper.childAt(2).prop('label')).toEqual('Type');
+    expect(wrapper.childAt(3).prop('label')).toEqual('Capacity Type');
+    expect(wrapper.childAt(4).prop('label')).toEqual('Server Group');
+
+    expect(wrapper.childAt(0).prop('value')).toEqual('1970-01-14 22:37:37 PST');
+    expect(wrapper.childAt(2).prop('value')).toEqual(testInstance.instanceType);
+    expect(wrapper.childAt(3).prop('value')).toEqual(testInstance.capacityType);
+  });
+
+  it('should render correct state when attributes are missing', () => {
+    const wrapper = shallow(
+      <InstanceInformation
+        account={testInstance.account}
+        availabilityZone={undefined}
+        instanceType={undefined}
+        capacityType={undefined}
+        launchTime={undefined}
+        provider={testInstance.provider}
+        region={testInstance.region}
+        serverGroup={undefined}
+        showInstanceType={true}
+      />,
+    );
+
+    const labeledValues = wrapper.find('LabeledValue');
+    expect(labeledValues.length).toEqual(3);
+
+    expect(wrapper.childAt(0).prop('label')).toEqual('Launched');
+    expect(wrapper.childAt(1).prop('label')).toEqual('In');
+    expect(wrapper.childAt(2).prop('label')).toEqual('Type');
+
+    expect(wrapper.childAt(0).prop('value')).toEqual('Unknown');
+    expect(wrapper.childAt(2).prop('value')).toEqual('Unknown');
+  });
+});

package/src/instance/details/InstanceInformation.tsx

@@ -0,0 +1,66 @@
+import { UISref } from '@uirouter/react';
+import { UIRouterContextComponent } from '@uirouter/react-hybrid';
+import React from 'react';
+
+import { AccountTag, LabeledValue, timestamp } from '@spinnaker/core';
+
+export interface IInstanceInformationProps {
+  account: string;
+  availabilityZone: string;
+  instanceType: string;
+  capacityType?: string;
+  launchTime: number;
+  provider: string;
+  region: string;
+  serverGroup: string;
+  showInstanceType?: boolean;
+}
+
+export const InstanceInformation = ({
+  account,
+  availabilityZone,
+  instanceType,
+  capacityType,
+  launchTime,
+  provider,
+  region,
+  serverGroup,
+  showInstanceType,
+}: IInstanceInformationProps) => (
+  <>
+    <LabeledValue label="Launched" value={launchTime ? timestamp(launchTime) : 'Unknown'} />
+    <LabeledValue
+      label="In"
+      value={
+        <div>
+          <AccountTag account={account} />
+          {availabilityZone || 'Unknown'}
+        </div>
+      }
+    />
+    {showInstanceType && <LabeledValue label="Type" value={instanceType || 'Unknown'} />}
+    {showInstanceType && capacityType && <LabeledValue label="Capacity Type" value={capacityType || 'Unknown'} />}
+    {serverGroup && (
+      <LabeledValue
+        label="Server Group"
+        value={
+          <div>
+            <UIRouterContextComponent>
+              <UISref
+                to="^.serverGroup"
+                params={{
+                  region,
+                  accountId: account,
+                  serverGroup,
+                  provider,
+                }}
+              >
+                <a>{serverGroup}</a>
+              </UISref>
+            </UIRouterContextComponent>
+          </div>
+        }
+      />
+    )}
+  </>
+);

package/src/instance/details/InstanceSecurityGroups.tsx

@@ -0,0 +1,45 @@
+import { UISref } from '@uirouter/react';
+import { UIRouterContextComponent } from '@uirouter/react-hybrid';
+import { orderBy } from 'lodash';
+import React from 'react';
+
+import { CollapsibleSection, FirewallLabels } from '@spinnaker/core';
+
+import type { IAmazonInstance } from '../../domain';
+
+export interface IInstanceSecurityGroupsProps {
+  instance: IAmazonInstance;
+}
+
+export const InstanceSecurityGroups = ({ instance }: IInstanceSecurityGroupsProps) => {
+  const { account, region, provider, securityGroups, vpcId } = instance;
+  const sortedSecurityGroups = orderBy(securityGroups, ['groupName'], ['asc']);
+  const securityGroupLabel = FirewallLabels.get('Firewalls');
+
+  return (
+    <CollapsibleSection heading={securityGroupLabel} defaultExpanded={true}>
+      <UIRouterContextComponent>
+        <ul>
+          {(sortedSecurityGroups || []).map((sg) => (
+            <li key={sg.groupId}>
+              <UISref
+                to="^.firewallDetails"
+                params={{
+                  name: sg.groupName,
+                  accountId: account,
+                  region,
+                  vpcId,
+                  provider,
+                }}
+              >
+                <a>
+                  {sg.groupName} ({sg.groupId})
+                </a>
+              </UISref>
+            </li>
+          ))}
+        </ul>
+      </UIRouterContextComponent>
+    </CollapsibleSection>
+  );
+};