@spinnaker/amazon 0.0.0-main-2

package/src/securityGroup/details/securityGroupDetail.html

@@ -0,0 +1,114 @@
+<div class="text-center" ng-if="state.notFound">
+  <h3>Could not find <firewall-label label="firewall"></firewall-label> {{group}}.</h3>
+  <a ui-sref="home.infrastructure">Back to search results</a>
+</div>
+<div class="details-panel" ng-if="!state.notFound">
+  <div class="header">
+    <div class="close-button" ng-if="!state.standalone">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <div ng-if="state.loading" class="horizontal center middle">
+      <loading-spinner size="'small'"></loading-spinner>
+    </div>
+    <div class="header-text horizontal middle" ng-if="!state.loading">
+      <span class="glyphicon glyphicon-transfer"></span>
+      <h3 class="horizontal middle space-between flex-1" select-on-dbl-click>
+        {{securityGroup.name || '(not found)'}}
+        <render-if-feature feature="entityTags">
+          <entity-notifications
+            entity="securityGroup"
+            application="ctrl.application"
+            placement="bottom"
+            h-offset-percent="90%"
+            entity-type="securityGroup"
+            page-location="details"
+            on-update="ctrl.application.securityGroups.refresh()"
+          ></entity-notifications>
+        </render-if-feature>
+      </h3>
+    </div>
+    <div class="actions" ng-hide="isDisabled">
+      <div class="dropdown" uib-dropdown dropdown-append-to-body>
+        <button type="button" class="btn btn-sm btn-primary dropdown-toggle" ng-disabled="disabled" uib-dropdown-toggle>
+          <firewall-label label="Firewall"></firewall-label> Actions <span class="caret"></span>
+        </button>
+        <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+          <li><a href ng-click="ctrl.editInboundRules()">Edit Inbound Rules</a></li>
+          <li>
+            <a href ng-click="ctrl.deleteSecurityGroup()">Delete <firewall-label label="Firewall"></firewall-label></a>
+          </li>
+          <li>
+            <a href ng-click="ctrl.cloneSecurityGroup()">Clone <firewall-label label="Firewall"></firewall-label></a>
+          </li>
+          <render-if-feature feature="entityTags">
+            <add-entity-tag-links
+              component="securityGroup"
+              application="ctrl.application"
+              entity-type="securityGroup"
+              on-update="ctrl.application.securityGroups.refresh"
+            ></add-entity-tag-links>
+          </render-if-feature>
+        </ul>
+      </div>
+    </div>
+  </div>
+  <managed-resource-details-indicator
+    ng-if="!state.loading && securityGroup.isManaged"
+    resource-summary="securityGroup.managedResourceSummary"
+    application="ctrl.application"
+  >
+  </managed-resource-details-indicator>
+  <div class="content" ng-if="!state.loading">
+    <collapsible-section heading="{{ctrl.firewallLabel}} Details" expanded="true">
+      <dl class="dl-horizontal dl-medium">
+        <dt>ID</dt>
+        <dd>{{securityGroup.id}}</dd>
+        <dt>Account</dt>
+        <dd>
+          <account-tag account="securityGroup.accountName"></account-tag>
+        </dd>
+        <dt>Region</dt>
+        <dd>{{securityGroup.region}}</dd>
+        <dt>VPC</dt>
+        <dd>
+          <vpc-tag vpc-id="securityGroup.vpcId"></vpc-tag>
+        </dd>
+        <dt>Description</dt>
+        <dd>{{securityGroup.description}}</dd>
+      </dl>
+    </collapsible-section>
+    <ip-range-rules ip-rules="ipRules"></ip-range-rules>
+    <collapsible-section
+      heading="{{ctrl.firewallLabel}} Rules ({{securityGroupRules.length || 0}})"
+      expanded="{{securityGroupRules.length > 0}}"
+    >
+      <div ng-if="!securityGroupRules.length">None</div>
+
+      <dl
+        ng-class="insightCtrl.vm.filtersExpanded ? '' : 'dl-horizontal dl-medium'"
+        ng-repeat="rule in securityGroupRules | orderBy: 'securityGroup.name' "
+      >
+        <dt>
+          <firewall-label label="Firewall"></firewall-label>
+        </dt>
+        <dd ng-if="rule.securityGroup.name">
+          <a
+            ui-sref="^.firewallDetails({name: rule.securityGroup.name, accountId: rule.securityGroup.accountName, region: rule.securityGroup.region, vpcId: rule.securityGroup.vpcId, provider: 'aws'})"
+          >
+            <account-tag
+              account="rule.securityGroup.accountName || rule.securityGroup.accountId"
+              ng-if="rule.securityGroup.accountName !== securityGroup.accountName"
+            ></account-tag>
+            {{rule.securityGroup.name}} ({{rule.securityGroup.id}})
+          </a>
+        </dd>
+        <dt>Port Ranges</dt>
+        <dd ng-repeat="portRange in rule.rules">
+          {{portRange.protocol}}: {{portRange.startPort}} &rarr; {{portRange.endPort}}
+        </dd>
+      </dl>
+    </collapsible-section>
+  </div>
+</div>

package/src/securityGroup/details/securityGroupIpRangeRules.component.ts

@@ -0,0 +1,12 @@
+import { module } from 'angular';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { IPRangeRules } from './IPRangeRules';
+
+export const AWS_SECURITY_GROUP_IP_RANGE_RULES = 'spinnaker.amazon.securityGroups.details.securityGroups.component';
+module(AWS_SECURITY_GROUP_IP_RANGE_RULES, []).component(
+  'ipRangeRules',
+  react2angular(withErrorBoundary(IPRangeRules, 'ipRangeRules'), ['ipRules']),
+);

package/src/securityGroup/index.ts

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

package/src/securityGroup/securityGroup.module.ts

@@ -0,0 +1,26 @@
+import { module } from 'angular';
+
+import { AMAZON_SECURITYGROUP_CLONE_CLONESECURITYGROUP_CONTROLLER } from './clone/cloneSecurityGroup.controller';
+import { AMAZON_SECURITYGROUP_CONFIGURE_CREATESECURITYGROUPCTRL } from './configure/CreateSecurityGroupCtrl';
+import { AMAZON_SECURITYGROUP_CONFIGURE_EDITSECURITYGROUPCTRL } from './configure/EditSecurityGroupCtrl';
+import { AMAZON_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUP_MIXIN_CONTROLLER } from './configure/configSecurityGroup.mixin.controller';
+import { INGRESS_RULE_GROUP_SELECTOR_COMPONENT } from './configure/ingressRuleGroupSelector.component';
+import { AWS_SECURITY_GROUP_DETAILS_CUSTOM } from './configure/securityGroupDetailsCustom.component';
+import { AMAZON_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER } from './details/securityGroupDetail.controller';
+import { AWS_SECURITY_GROUP_IP_RANGE_RULES } from './details/securityGroupIpRangeRules.component';
+import { AWS_SECURITY_GROUP_READER } from './securityGroup.reader';
+import { AMAZON_SECURITYGROUP_SECURITYGROUP_TRANSFORMER } from './securityGroup.transformer';
+
+export const AWS_SECURITY_GROUP_MODULE = 'spinnaker.amazon.securityGroup';
+module(AWS_SECURITY_GROUP_MODULE, [
+  AWS_SECURITY_GROUP_READER,
+  AMAZON_SECURITYGROUP_CLONE_CLONESECURITYGROUP_CONTROLLER,
+  INGRESS_RULE_GROUP_SELECTOR_COMPONENT,
+  AMAZON_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUP_MIXIN_CONTROLLER,
+  AMAZON_SECURITYGROUP_CONFIGURE_CREATESECURITYGROUPCTRL,
+  AMAZON_SECURITYGROUP_CONFIGURE_EDITSECURITYGROUPCTRL,
+  AMAZON_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER,
+  AMAZON_SECURITYGROUP_SECURITYGROUP_TRANSFORMER,
+  AWS_SECURITY_GROUP_IP_RANGE_RULES,
+  AWS_SECURITY_GROUP_DETAILS_CUSTOM,
+]);

package/src/securityGroup/securityGroup.reader.ts

@@ -0,0 +1,24 @@
+import { module } from 'angular';
+
+import type { ISecurityGroup, ISecurityGroupsByAccount } from '@spinnaker/core';
+
+export class AwsSecurityGroupReader {
+  public resolveIndexedSecurityGroup(
+    indexedSecurityGroups: ISecurityGroupsByAccount,
+    container: ISecurityGroup,
+    securityGroupId: string,
+  ): ISecurityGroup {
+    return AwsSecurityGroupReader.resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId);
+  }
+
+  public static resolveIndexedSecurityGroup(
+    indexedSecurityGroups: ISecurityGroupsByAccount,
+    container: ISecurityGroup,
+    securityGroupId: string,
+  ): ISecurityGroup {
+    return indexedSecurityGroups[container.account][container.region][securityGroupId];
+  }
+}
+
+export const AWS_SECURITY_GROUP_READER = 'spinnaker.amazon.securityGroup.reader';
+module(AWS_SECURITY_GROUP_READER, []).service('awsSecurityGroupReader', AwsSecurityGroupReader);

package/src/securityGroup/securityGroup.transformer.js

@@ -0,0 +1,48 @@
+'use strict';
+
+import { module } from 'angular';
+import { groupBy } from 'lodash';
+
+import { VpcReader } from '../vpc/VpcReader';
+
+export const AMAZON_SECURITYGROUP_SECURITYGROUP_TRANSFORMER = 'spinnaker.amazon.securityGroup.transformer';
+export const name = AMAZON_SECURITYGROUP_SECURITYGROUP_TRANSFORMER; // for backwards compatibility
+module(AMAZON_SECURITYGROUP_SECURITYGROUP_TRANSFORMER, []).factory('awsSecurityGroupTransformer', function () {
+  function normalizeSecurityGroup(securityGroup) {
+    return VpcReader.listVpcs().then(addVpcNameToSecurityGroup(securityGroup));
+  }
+
+  function addVpcNameToSecurityGroup(securityGroup) {
+    return function (vpcs) {
+      const matches = vpcs.filter(function (test) {
+        return test.id === securityGroup.vpcId;
+      });
+      securityGroup.vpcName = matches.length ? matches[0].name : '';
+    };
+  }
+
+  function compress(securityGroups) {
+    const grouped = groupBy(securityGroups, 'vpcId');
+    Object.keys(grouped).forEach((vpcId) => {
+      grouped[vpcId] = grouped[vpcId].map((g) => [g.name, g.id]);
+    });
+    return grouped;
+  }
+
+  function decompress(groupedGroups) {
+    const flattened = [];
+    Object.keys(groupedGroups).forEach((vpcId) => {
+      groupedGroups[vpcId].forEach((g) => {
+        flattened.push({ name: g[0], id: g[1], vpcId });
+      });
+    });
+    return flattened;
+  }
+
+  return {
+    normalizeSecurityGroup,
+    compress,
+    decompress,
+    supportsCompression: true,
+  };
+});

package/src/serverGroup/AvailabilityZoneSelector.tsx

@@ -0,0 +1,107 @@
+import React from 'react';
+
+import { AccountService, ChecklistInput } from '@spinnaker/core';
+
+export interface IAvailabilityZoneSelectorProps {
+  region: string;
+  credentials: string;
+  onChange: (zones: string[]) => void;
+  allZones: string[];
+  usePreferredZones?: boolean;
+  selectedZones: string[];
+}
+
+export interface IAvailabilityZoneSelectorState {
+  defaultZones: string[];
+  usePreferredZones: boolean;
+}
+
+export class AvailabilityZoneSelector extends React.Component<
+  IAvailabilityZoneSelectorProps,
+  IAvailabilityZoneSelectorState
+> {
+  constructor(props: IAvailabilityZoneSelectorProps) {
+    super(props);
+    this.state = {
+      defaultZones: [],
+      usePreferredZones: props.usePreferredZones || !props.selectedZones || props.selectedZones.length === 0,
+    };
+
+    this.setDefaultZones(this.state.usePreferredZones, props);
+  }
+
+  public componentWillReceiveProps(nextProps: IAvailabilityZoneSelectorProps): void {
+    if (nextProps.region !== this.props.region || nextProps.credentials !== this.props.credentials) {
+      this.setDefaultZones(this.state.usePreferredZones, nextProps);
+    }
+  }
+
+  private setDefaultZones(usePreferredZones: boolean, props: IAvailabilityZoneSelectorProps) {
+    const { credentials, region } = props;
+
+    AccountService.getAvailabilityZonesForAccountAndRegion('aws', credentials, region).then((preferredZones) => {
+      this.setState({ defaultZones: preferredZones });
+      if (usePreferredZones && preferredZones) {
+        props.onChange(preferredZones.slice());
+      }
+    });
+  }
+
+  private handleUsePreferredZonesChanged = (event: React.ChangeEvent<HTMLSelectElement>): void => {
+    const usePreferredZones = event.target.value === 'true';
+    this.setState({ usePreferredZones });
+
+    if (usePreferredZones) {
+      this.setDefaultZones(usePreferredZones, this.props);
+    }
+  };
+
+  private handleSelectedZonesChanged = (zones: Set<string>): void => {
+    this.props.onChange([...zones]);
+  };
+
+  public render(): React.ReactElement<AvailabilityZoneSelector> {
+    const { region, allZones, selectedZones } = this.props;
+    const { defaultZones, usePreferredZones } = this.state;
+
+    return (
+      <div className="form-group">
+        <div className="col-md-3 sm-label-right">Availability Zones</div>
+        {region && (
+          <div className="col-md-7">
+            <p className="form-control-static">Automatic Availability Zone Balancing:</p>
+            <select
+              className="form-control input-sm"
+              value={usePreferredZones ? 'true' : 'false'}
+              onChange={this.handleUsePreferredZonesChanged}
+            >
+              <option value="true">Enabled</option>
+              <option value="false">Manual</option>
+            </select>
+            <br />
+            {usePreferredZones && (
+              <div>
+                <p className="form-control-static">Server group will be available in:</p>
+                <ul>
+                  {defaultZones.map((zone) => (
+                    <li key={zone}>{zone}</li>
+                  ))}
+                </ul>
+              </div>
+            )}
+            {!usePreferredZones && (
+              <div>
+                Restrict server group instances to:
+                <ChecklistInput
+                  stringOptions={allZones}
+                  value={selectedZones}
+                  onChange={(e: React.ChangeEvent<any>) => this.handleSelectedZonesChanged(e.target.value)}
+                />
+              </div>
+            )}
+          </div>
+        )}
+      </div>
+    );
+  }
+}

package/src/serverGroup/configure/AccountServiceFixtures.js

@@ -0,0 +1,45 @@
+const AccountServiceFixture = {};
+AccountServiceFixture.credentialsKeyedByAccount = {
+  test: {
+    regions: [
+      {
+        name: 'us-east-1',
+        availabilityZones: ['a', 'b', 'c'],
+      },
+      {
+        name: 'us-west-1',
+        availabilityZones: ['b', 'c', 'd'],
+      },
+    ],
+  },
+  prod: {
+    regions: [
+      {
+        name: 'us-east-1',
+        availabilityZones: ['a', 'b', 'c', 'd', 'e'],
+      },
+      {
+        name: 'us-west-1',
+        availabilityZones: ['a', 'b', 'c', 'g', 'h', 'i'],
+      },
+    ],
+  },
+};
+
+AccountServiceFixture.preferredZonesByAccount = {
+  test: {
+    'us-east-1': ['a', 'b', 'c'],
+    'us-west-2': ['a', 'b', 'c'],
+    'us-west-1': ['c', 'd'],
+  },
+  prod: {
+    'us-east-1': ['d', 'e'],
+    'us-west-1': ['g', 'h', 'i'],
+  },
+  default: {
+    'us-east-1': ['a', 'b', 'c'],
+    'us-west-1': ['c', 'd'],
+  },
+};
+
+module.exports = AccountServiceFixture;

package/src/serverGroup/configure/AmazonImageSelectInput.spec.tsx

@@ -0,0 +1,101 @@
+import { mock } from 'angular';
+import type { ReactWrapper, ShallowWrapper } from 'enzyme';
+import { mount, shallow } from 'enzyme';
+import React from 'react';
+
+import { Application } from '@spinnaker/core';
+import { REACT_MODULE } from '@spinnaker/core';
+
+import type { IAmazonImageSelectorProps, IAmazonImageSelectorState } from './AmazonImageSelectInput';
+import { AmazonImageSelectInput } from './AmazonImageSelectInput';
+// eslint-disable-next-line @spinnaker/import-from-npm-not-relative
+import { mockHttpClient } from '../../../../core/src/api/mock/jasmine';
+import type { IAmazonImage } from '../../image';
+const application = new Application('testapp', null, []);
+const region = 'us-region-1';
+const credentials = 'prodaccount';
+const imageName = 'fancypackage-1.0.0-h005.6c8b5fe-x86_64-20181206030728-xenial-hvm-sriov-ebs';
+const amiId = 'fake-abcd123';
+
+describe('<AmazonImageSelectInput/>', () => {
+  let shallowComponent: ShallowWrapper<IAmazonImageSelectorProps, IAmazonImageSelectorState>;
+  let mountedComponent: ReactWrapper<IAmazonImageSelectorProps, IAmazonImageSelectorState>;
+
+  beforeEach(mock.module(REACT_MODULE));
+  beforeEach(mock.inject());
+
+  afterEach(() => {
+    shallowComponent && shallowComponent.unmount();
+    mountedComponent && mountedComponent.unmount();
+  });
+
+  const baseProps = {
+    application,
+    credentials,
+    region,
+    value: {} as IAmazonImage,
+    onChange: () => null as any,
+  };
+
+  describe('fetches package images when mounted', () => {
+    it('using application name when no amiId is present in the initial value', async () => {
+      const http = mockHttpClient();
+      http.expectGET(`/images/find?q=testapp*`).respond(200, []);
+      shallowComponent = shallow(<AmazonImageSelectInput {...baseProps} />);
+      await http.flush();
+    });
+
+    it('and updates isLoadingPackageImages', async () => {
+      const http = mockHttpClient();
+      http.expectGET(`/images/find?q=testapp*`).respond(200, []);
+      shallowComponent = shallow(<AmazonImageSelectInput {...baseProps} />);
+      expect(shallowComponent.state().isLoadingPackageImages).toBe(true);
+      await http.flush();
+      expect(shallowComponent.state().isLoadingPackageImages).toBe(false);
+    });
+
+    it('using fetching image by amiId and looking up via the imageName', async () => {
+      const http = mockHttpClient();
+      const value = AmazonImageSelectInput.makeFakeImage(imageName, amiId, region);
+      http.expectGET(`/images/${credentials}/${region}/${amiId}?provider=aws`).respond(200, [value]);
+      http.expectGET(`/images/find?q=fancypackage-*`).respond(200, []);
+      shallowComponent = shallow(<AmazonImageSelectInput {...baseProps} value={value} />);
+      await http.flush();
+    });
+
+    it('using application name when an amiId is present in the initial value, but the image was not found', async () => {
+      const http = mockHttpClient();
+      const value = AmazonImageSelectInput.makeFakeImage(imageName, amiId, region);
+      http.expectGET(`/images/${credentials}/${region}/${amiId}?provider=aws`).respond(200, null);
+      http.expectGET(`/images/find?q=${application.name}*`).respond(200, []);
+      shallowComponent = shallow(<AmazonImageSelectInput {...baseProps} value={value} />);
+      await http.flush();
+    });
+  });
+
+  it('calls onChange with the backend image when the package images are loaded', async () => {
+    const http = mockHttpClient();
+    const value = AmazonImageSelectInput.makeFakeImage(imageName, amiId, region);
+    const backendValue = AmazonImageSelectInput.makeFakeImage(imageName, amiId, region);
+    const onChange = jasmine.createSpy('onChange');
+    http.expectGET(`/images/${credentials}/${region}/${amiId}?provider=aws`).respond(200, [backendValue]);
+    http.expectGET(`/images/find?q=fancypackage-*`).respond(200, [backendValue]);
+    mountedComponent = mount(<AmazonImageSelectInput {...baseProps} onChange={onChange} value={value} />);
+    await http.flush();
+
+    expect(onChange).toHaveBeenCalledWith(backendValue);
+  });
+
+  it('calls onChange with null image when the image is not found in the package images', async () => {
+    const http = mockHttpClient();
+    const value = AmazonImageSelectInput.makeFakeImage(imageName, amiId, region);
+    const noResults = [] as IAmazonImage[];
+    http.expectGET(`/images/${credentials}/${region}/${amiId}?provider=aws`).respond(200, noResults);
+    http.expectGET(`/images/find?q=testapp*`).respond(200, noResults);
+    const onChange = jasmine.createSpy('onChange');
+    mountedComponent = mount(<AmazonImageSelectInput {...baseProps} onChange={onChange} value={value} />);
+    await http.flush();
+
+    expect(onChange).toHaveBeenCalledWith(undefined);
+  });
+});