@spinnaker/ecs 0.0.0-main-2

package/src/securityGroup/details/securityGroupDetail.controller.js

@@ -0,0 +1,147 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import { VpcReader } from '@spinnaker/amazon';
+import {
+  CloudProviderRegistry,
+  FirewallLabels,
+  MANAGED_RESOURCE_DETAILS_INDICATOR,
+  RecentHistoryService,
+  SECURITY_GROUP_READER,
+} from '@spinnaker/core';
+
+export const ECS_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER =
+  'spinnaker.ecs.securityGroup.details.controller';
+export const name = ECS_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER; // for backwards compatibility
+angular
+  .module(ECS_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER, [
+    UIROUTER_ANGULARJS,
+    SECURITY_GROUP_READER,
+    MANAGED_RESOURCE_DETAILS_INDICATOR,
+  ])
+  .controller('ecsSecurityGroupDetailsCtrl', [
+    '$scope',
+    '$state',
+    'resolvedSecurityGroup',
+    'app',
+    'securityGroupReader',
+    function ($scope, $state, resolvedSecurityGroup, app, securityGroupReader) {
+      this.application = app;
+      const application = app;
+      const securityGroup = resolvedSecurityGroup;
+      this.firewallLabel = FirewallLabels.get('Firewall');
+
+      // needed for standalone instances
+      $scope.detailsTemplateUrl = CloudProviderRegistry.getValue('ecs', 'securityGroup.detailsTemplateUrl');
+
+      $scope.state = {
+        loading: true,
+        standalone: app.isStandalone,
+      };
+
+      function extractSecurityGroup() {
+        return securityGroupReader
+          .getSecurityGroupDetails(
+            application,
+            securityGroup.accountId,
+            securityGroup.provider,
+            securityGroup.region,
+            securityGroup.vpcId,
+            securityGroup.name,
+          )
+          .then(function (details) {
+            return VpcReader.getVpcName(details.vpcId).then((name) => {
+              details.vpcName = name;
+              return details;
+            });
+          })
+          .then(function (details) {
+            $scope.state.loading = false;
+
+            if (!details || _.isEmpty(details)) {
+              fourOhFour();
+            } else {
+              const applicationSecurityGroup = securityGroupReader.getApplicationSecurityGroup(
+                application,
+                securityGroup.accountId,
+                securityGroup.region,
+                securityGroup.name,
+              );
+
+              angular.extend(securityGroup, applicationSecurityGroup, details);
+              $scope.securityGroup = securityGroup;
+              $scope.ipRules = buildIpRulesModel(securityGroup);
+              $scope.securityGroupRules = buildSecurityGroupRulesModel(securityGroup);
+            }
+          }, fourOhFour);
+      }
+
+      function buildIpRulesModel(details) {
+        const groupedRangeRules = _.groupBy(details.ipRangeRules, (rule) => rule.range.ip + rule.range.cidr);
+        return Object.keys(groupedRangeRules)
+          .map((addr) => {
+            return {
+              address: addr,
+              rules: buildRuleModel(groupedRangeRules, addr),
+            };
+          })
+          .filter((rule) => rule.rules.length);
+      }
+
+      function buildSecurityGroupRulesModel(details) {
+        const groupedRangeRules = _.groupBy(details.securityGroupRules, (rule) => rule.securityGroup.id);
+        return Object.keys(groupedRangeRules)
+          .map((addr) => {
+            return {
+              securityGroup: groupedRangeRules[addr][0].securityGroup,
+              rules: buildRuleModel(groupedRangeRules, addr),
+            };
+          })
+          .filter((rule) => rule.rules.length);
+      }
+
+      function buildRuleModel(groupedRangeRules, addr) {
+        const rules = [];
+        groupedRangeRules[addr].forEach((rule) => {
+          (rule.portRanges || []).forEach((range) => {
+            if (rule.protocol === '-1' || (range.startPort !== undefined && range.endPort !== undefined)) {
+              rules.push({ startPort: range.startPort, endPort: range.endPort, protocol: rule.protocol });
+            }
+          });
+        });
+        return rules;
+      }
+
+      function fourOhFour() {
+        if ($scope.$$destroyed) {
+          return;
+        }
+        if (app.isStandalone) {
+          $scope.group = securityGroup.name;
+          $scope.state.notFound = true;
+          $scope.state.loading = false;
+          RecentHistoryService.removeLastItem('securityGroups');
+        } else {
+          $state.go('^', { allowModalToStayOpen: true }, { location: 'replace' });
+        }
+      }
+
+      extractSecurityGroup().then(() => {
+        // If the user navigates away from the view before the initial extractSecurityGroup call completes,
+        // do not bother subscribing to the refresh
+        if (!$scope.$$destroyed && !app.isStandalone) {
+          app.securityGroups.onRefresh($scope, extractSecurityGroup);
+        }
+      });
+
+      if (app.isStandalone) {
+        // we still want the edit to refresh the firewall details when the modal closes
+        app.securityGroups = {
+          refresh: extractSecurityGroup,
+        };
+      }
+    },
+  ]);

package/src/securityGroup/details/securityGroupDetail.html

@@ -0,0 +1,104 @@
+<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>
+  <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>
+    <collapsible-section heading="IP Range Rules ({{ipRules.length}})" expanded="{{ipRules.length > 0}}">
+      <div ng-if="!ipRules.length">None</div>
+
+      <dl
+        ng-class="insightCtrl.vm.filtersExpanded ? '' : 'dl-horizontal dl-medium'"
+        ng-repeat="ipRangeRule in ipRules | orderBy: 'range.address'"
+      >
+        <dt>IP Range</dt>
+        <dd>{{ipRangeRule.address}}</dd>
+        <dt>Port Ranges</dt>
+        <dd ng-repeat="rule in ipRangeRule.rules">
+          <span ng-if="rule.protocol === '-1'">
+            All ports and protocols
+            <div ng-if="ipRangeRule.rules.length > 1">
+              <em>Additional port ranges are specified, but redundant:</em>
+            </div>
+          </span>
+          <span ng-if="rule.protocol !== '-1'"> {{rule.protocol}}: {{rule.startPort}} &rarr; {{rule.endPort}} </span>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <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: 'ecs'})"
+          >
+            <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/securityGroup.module.ts

@@ -0,0 +1,12 @@
+import { module } from 'angular';
+
+import { ECS_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER } from './details/securityGroupDetail.controller';
+import { ECS_SECURITY_GROUP_READER } from './securityGroup.reader';
+import { ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER } from './securityGroup.transformer';
+
+export const ECS_SECURITY_GROUP_MODULE = 'spinnaker.ecs.securityGroup';
+module(ECS_SECURITY_GROUP_MODULE, [
+  ECS_SECURITY_GROUP_READER,
+  ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER,
+  ECS_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER,
+]);

package/src/securityGroup/securityGroup.reader.ts

@@ -0,0 +1,16 @@
+import { module } from 'angular';
+
+import type { ISecurityGroup, ISecurityGroupsByAccount } from '@spinnaker/core';
+
+export class EcsSecurityGroupReader {
+  public resolveIndexedSecurityGroup(
+    indexedSecurityGroups: ISecurityGroupsByAccount,
+    container: ISecurityGroup,
+    securityGroupId: string,
+  ): ISecurityGroup {
+    return indexedSecurityGroups[container.account][container.region][securityGroupId];
+  }
+}
+
+export const ECS_SECURITY_GROUP_READER = 'spinnaker.ecs.securityGroup.reader';
+module(ECS_SECURITY_GROUP_READER, []).service('ecsSecurityGroupReader', EcsSecurityGroupReader);

package/src/securityGroup/securityGroup.transformer.js

@@ -0,0 +1,13 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER = 'spinnaker.ecs.securityGroup.transformer';
+export const name = ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER; // for backwards compatibility
+module(ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER, []).factory('ecsSecurityGroupTransformer', function () {
+  function normalizeSecurityGroup() {}
+
+  return {
+    normalizeSecurityGroup: normalizeSecurityGroup,
+  };
+});

package/src/serverGroup/configure/serverGroupCommandBuilder.service.js

@@ -0,0 +1,281 @@
+'use strict';
+
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import { AccountService, INSTANCE_TYPE_SERVICE } from '@spinnaker/core';
+
+import { ECS_SERVER_GROUP_CONFIGURATION_SERVICE } from './serverGroupConfiguration.service';
+
+export const ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE =
+  'spinnaker.ecs.serverGroupCommandBuilder.service';
+export const name = ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE; // for backwards compatibility
+angular
+  .module(ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE, [
+    INSTANCE_TYPE_SERVICE,
+    ECS_SERVER_GROUP_CONFIGURATION_SERVICE,
+  ])
+  .factory('ecsServerGroupCommandBuilder', [
+    '$q',
+    'instanceTypeService',
+    'ecsServerGroupConfigurationService',
+    function ($q, instanceTypeService, ecsServerGroupConfigurationService) {
+      function reconcileUpstreamImages(image, upstreamImages) {
+        if (image.fromContext) {
+          const matchingImage = upstreamImages.find((otherImage) => image.stageId === otherImage.stageId);
+
+          if (matchingImage) {
+            image.cluster = matchingImage.cluster;
+            image.pattern = matchingImage.pattern;
+            image.repository = matchingImage.repository;
+            return image;
+          } else {
+            return null;
+          }
+        } else if (image.fromTrigger) {
+          const matchingImage = upstreamImages.find((otherImage) => {
+            return (
+              image.registry === otherImage.registry &&
+              image.repository === otherImage.repository &&
+              image.tag === otherImage.tag
+            );
+          });
+
+          if (matchingImage) {
+            return image;
+          } else {
+            return null;
+          }
+        } else {
+          return image;
+        }
+      }
+
+      function findUpstreamImages(current, all, visited = {}) {
+        // This actually indicates a loop in the stage dependencies.
+        if (visited[current.refId]) {
+          return [];
+        } else {
+          visited[current.refId] = true;
+        }
+        let result = [];
+        if (current.type === 'findImageFromTags') {
+          result.push({
+            fromContext: true,
+            imageLabelOrSha: current.imageLabelOrSha,
+            stageId: current.refId,
+          });
+        }
+        current.requisiteStageRefIds.forEach(function (id) {
+          const next = all.find((stage) => stage.refId === id);
+          if (next) {
+            result = result.concat(findUpstreamImages(next, all, visited));
+          }
+        });
+
+        return result;
+      }
+
+      function findTriggerImages(triggers) {
+        const result = triggers
+          .filter((trigger) => {
+            return trigger.type === 'docker';
+          })
+          .map((trigger) => {
+            return {
+              fromTrigger: true,
+              repository: trigger.repository,
+              account: trigger.account,
+              organization: trigger.organization,
+              registry: trigger.registry,
+              tag: trigger.tag,
+            };
+          });
+
+        return result;
+      }
+
+      function buildNewServerGroupCommand(application, defaults) {
+        defaults = defaults || {};
+        const credentialsLoader = AccountService.getCredentialsKeyedByAccount('ecs');
+
+        const defaultCredentials = defaults.account || application.defaultCredentials.ecs;
+        const defaultRegion = defaults.region || application.defaultRegions.ecs;
+
+        const preferredZonesLoader = AccountService.getAvailabilityZonesForAccountAndRegion(
+          'ecs',
+          defaultCredentials,
+          defaultRegion,
+        );
+
+        return $q
+          .all({
+            preferredZones: preferredZonesLoader,
+            credentialsKeyedByAccount: credentialsLoader,
+          })
+          .then(function (asyncData) {
+            const availabilityZones = asyncData.preferredZones;
+
+            let defaultIamRole = 'None (No IAM role)';
+            defaultIamRole = defaultIamRole.replace('{{application}}', application.name);
+
+            const defaultImageCredentials = 'None (No registry credentials)';
+
+            const command = {
+              application: application.name,
+              credentials: defaultCredentials,
+              region: defaultRegion,
+              strategy: '',
+              capacity: {
+                min: 1,
+                max: 1,
+                desired: 1,
+              },
+              launchType: 'EC2',
+              healthCheckType: 'EC2',
+              selectedProvider: 'ecs',
+              iamRole: defaultIamRole,
+              dockerImageCredentialsSecret: defaultImageCredentials,
+              availabilityZones: availabilityZones,
+              subnetType: '',
+              securityGroupNames: [],
+              healthCheckGracePeriodSeconds: '',
+              placementConstraints: [],
+              placementStrategyName: '',
+              taskDefinitionArtifact: {},
+              useTaskDefinitionArtifact: false,
+              placementStrategySequence: [],
+              serviceDiscoveryAssociations: [],
+              ecsClusterName: '',
+              targetGroup: '',
+              copySourceScalingPoliciesAndActions: true,
+              preferSourceCapacity: true,
+              useSourceCapacity: true,
+              enableDeploymentCircuitBreaker: false,
+              viewState: {
+                useAllImageSelection: false,
+                useSimpleCapacity: true,
+                usePreferredZones: true,
+                mode: defaults.mode || 'create',
+                disableStrategySelection: true,
+                dirty: {},
+              },
+            };
+
+            if (
+              application.attributes &&
+              application.attributes.platformHealthOnlyShowOverride &&
+              application.attributes.platformHealthOnly
+            ) {
+              command.interestingHealthProviderNames = ['ecs'];
+            }
+
+            return command;
+          });
+      }
+
+      function buildServerGroupCommandFromPipeline(application, originalCluster, current, pipeline) {
+        const pipelineCluster = _.cloneDeep(originalCluster);
+        const region = Object.keys(pipelineCluster.availabilityZones)[0];
+        // var instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType('ecs', pipelineCluster.instanceType);
+
+        const commandOptions = { account: pipelineCluster.account, region: region };
+        return buildNewServerGroupCommand(application, commandOptions).then(function (command) {
+          const zones = pipelineCluster.availabilityZones[region];
+          const usePreferredZones = zones.join(',') === command.availabilityZones.join(',');
+
+          let contextImages = findUpstreamImages(current, pipeline.stages) || [];
+          contextImages = contextImages.concat(findTriggerImages(pipeline.triggers));
+
+          if (command.docker && command.docker.image) {
+            command.docker.image = reconcileUpstreamImages(command.docker.image, contextImages);
+          }
+
+          const viewState = {
+            instanceProfile: undefined,
+            disableImageSelection: true,
+            useSimpleCapacity:
+              pipelineCluster.capacity.min === pipelineCluster.capacity.max &&
+              pipelineCluster.useSourceCapacity !== true,
+            usePreferredZones: usePreferredZones,
+            mode: 'editPipeline',
+            submitButtonLabel: 'Done',
+            templatingEnabled: true,
+            existingPipelineCluster: true,
+            dirty: {},
+            contextImages: contextImages,
+            pipeline: pipeline,
+            currentStage: current,
+          };
+
+          const viewOverrides = {
+            region: region,
+            credentials: pipelineCluster.account,
+            availabilityZones: pipelineCluster.availabilityZones[region],
+            viewState: viewState,
+          };
+
+          pipelineCluster.strategy = pipelineCluster.strategy || '';
+
+          return angular.extend({}, command, pipelineCluster, viewOverrides);
+        });
+      }
+
+      // Only used to prepare view requiring template selecting
+      function buildNewServerGroupCommandForPipeline(current, pipeline) {
+        let contextImages = findUpstreamImages(current, pipeline.stages) || [];
+        contextImages = contextImages.concat(findTriggerImages(pipeline.triggers));
+
+        return $q.when({
+          viewState: {
+            requiresTemplateSelection: true,
+            // applies viewState overrides after template selection
+            overrides: {
+              viewState: {
+                mode: 'editPipeline',
+                contextImages: contextImages,
+                pipeline: pipeline,
+                currentStage: current,
+              },
+            },
+          },
+        });
+      }
+
+      function buildUpdateServerGroupCommand(serverGroup) {
+        const command = {
+          type: 'modifyAsg',
+          asgs: [{ asgName: serverGroup.name, region: serverGroup.region }],
+          healthCheckType: serverGroup.asg.healthCheckType,
+          credentials: serverGroup.account,
+        };
+        ecsServerGroupConfigurationService.configureUpdateCommand(command);
+        return command;
+      }
+
+      function buildServerGroupCommandFromExisting(application, serverGroup, mode = 'clone') {
+        // do NOT copy: deployment strategy. DO copy: account, region, cluster name, stack
+        // TODO: query for & pull in ECS-specific data that would be useful, e.g, network mode, launch type
+        const commandOptions = { account: serverGroup.account, region: serverGroup.region };
+        return buildNewServerGroupCommand(application, commandOptions).then(function (command) {
+          command.credentials = serverGroup.account;
+          command.app = serverGroup.moniker.app;
+          command.stack = serverGroup.moniker.stack;
+          command.region = serverGroup.region;
+          command.ecsClusterName = serverGroup.ecsCluster;
+          command.capacity = serverGroup.capacity;
+          command.viewState.mode = mode;
+
+          return command;
+        });
+      }
+
+      return {
+        buildNewServerGroupCommand: buildNewServerGroupCommand,
+        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
+        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
+        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
+        buildUpdateServerGroupCommand: buildUpdateServerGroupCommand,
+      };
+    },
+  ]);