@spinnaker/google 0.0.0-2025.1-0

package/src/pipeline/stages/scaleDownCluster/scaleDownClusterStage.html

@@ -0,0 +1,35 @@
+<div ng-controller="gceScaleDownClusterStageCtrl as scaleDownClusterStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Scale Down Options">
+    <div class="form-inline">
+      <p>
+        Keep the
+        <input
+          type="number"
+          min="0"
+          required
+          ng-model="stage.remainingFullSizeServerGroups"
+          class="form-control input-sm"
+          style="width: 50px"
+        />
+        <select class="form-control input-sm" ng-model="stage.preferLargerOverNewer" style="width: 100px">
+          <option value="true">largest</option>
+          <option value="false">newest</option>
+        </select>
+        {{scaleDownClusterStageCtrl.pluralize('server group', stage.remainingFullSizeServerGroups)}} at current size.
+      </p>
+      <p>The remaining server groups will be scaled down to zero instances.</p>
+    </div>
+  </stage-config-field>
+  <div class="form-group">
+    <div class="col-md-offset-3 col-md-6 checkbox">
+      <label>
+        <input type="checkbox" ng-model="stage.allowScaleDownActive" />
+        Allow scale down of active server groups
+      </label>
+    </div>
+  </div>
+</div>

package/src/pipeline/stages/shrinkCluster/gceShrinkClusterStage.js

@@ -0,0 +1,73 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, Registry } from '@spinnaker/core';
+
+export const GOOGLE_PIPELINE_STAGES_SHRINKCLUSTER_GCESHRINKCLUSTERSTAGE =
+  'spinnaker.gce.pipeline.stage..shrinkClusterStage';
+export const name = GOOGLE_PIPELINE_STAGES_SHRINKCLUSTER_GCESHRINKCLUSTERSTAGE; // for backwards compatibility
+module(GOOGLE_PIPELINE_STAGES_SHRINKCLUSTER_GCESHRINKCLUSTERSTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'shrinkCluster',
+      cloudProvider: 'gce',
+      templateUrl: require('./shrinkClusterStage.html'),
+      accountExtractor: (stage) => [stage.context.credentials],
+      configAccountExtractor: (stage) => [stage.credentials],
+      validators: [
+        { type: 'requiredField', fieldName: 'cluster' },
+        { type: 'requiredField', fieldName: 'shrinkToSize', fieldLabel: 'shrink to [X] Server Groups' },
+        { type: 'requiredField', fieldName: 'regions' },
+        { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+      ],
+    });
+  })
+  .controller('gceShrinkClusterStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const ctrl = this;
+
+      const stage = $scope.stage;
+
+      $scope.state = {
+        accounts: false,
+        regionsLoaded: false,
+      };
+
+      AccountService.listAccounts('gce').then(function (accounts) {
+        $scope.accounts = accounts;
+        $scope.state.accounts = true;
+      });
+
+      stage.regions = stage.regions || [];
+      stage.cloudProvider = 'gce';
+
+      if (!stage.credentials && $scope.application.defaultCredentials.gce) {
+        stage.credentials = $scope.application.defaultCredentials.gce;
+      }
+      if (!stage.regions.length && $scope.application.defaultRegions.gce) {
+        stage.regions.push($scope.application.defaultRegions.gce);
+      }
+
+      if (stage.shrinkToSize === undefined) {
+        stage.shrinkToSize = 1;
+      }
+
+      if (stage.allowDeleteActive === undefined) {
+        stage.allowDeleteActive = false;
+      }
+
+      ctrl.pluralize = function (str, val) {
+        if (val === 1) {
+          return str;
+        }
+        return str + 's';
+      };
+
+      if (stage.retainLargerOverNewer === undefined) {
+        stage.retainLargerOverNewer = 'false';
+      }
+      stage.retainLargerOverNewer = stage.retainLargerOverNewer.toString();
+    },
+  ]);

package/src/pipeline/stages/shrinkCluster/shrinkClusterStage.html

@@ -0,0 +1,34 @@
+<div ng-controller="gceShrinkClusterStageCtrl as shrinkClusterStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Shrink Options">
+    <div class="form-inline">
+      Shrink to
+      <input
+        type="number"
+        min="0"
+        required
+        ng-model="stage.shrinkToSize"
+        class="form-control input-sm"
+        style="width: 50px"
+      />
+      {{shrinkClusterStageCtrl.pluralize('server group', stage.shrinkToSize)}}, keeping the
+      <select class="form-control input-sm" ng-model="stage.retainLargerOverNewer" style="width: 100px">
+        <option value="true">largest</option>
+        <option value="false">newest</option>
+      </select>
+    </div>
+  </stage-config-field>
+  <div class="form-group">
+    <div class="col-md-offset-3 col-md-6 checkbox">
+      <label>
+        <input type="checkbox" ng-model="stage.allowDeleteActive" />
+        Allow deletion of active server groups
+      </label>
+    </div>
+  </div>
+  <stage-platform-health-override application="application" stage="stage" platform-health-type="'Google'">
+  </stage-platform-health-override>
+</div>

package/src/pipeline/stages/tagImage/gceTagImageStage.js

@@ -0,0 +1,36 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, PipelineConfigService, Registry, StageConstants } from '@spinnaker/core';
+
+export const GOOGLE_PIPELINE_STAGES_TAGIMAGE_GCETAGIMAGESTAGE = 'spinnaker.gce.pipeline.stage..tagImageStage';
+export const name = GOOGLE_PIPELINE_STAGES_TAGIMAGE_GCETAGIMAGESTAGE; // for backwards compatibility
+module(GOOGLE_PIPELINE_STAGES_TAGIMAGE_GCETAGIMAGESTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'upsertImageTags',
+      cloudProvider: 'gce',
+      templateUrl: require('./tagImageStage.html'),
+      executionDetailsUrl: require('./tagImageExecutionDetails.html'),
+      executionConfigSections: ['tagImageConfig', 'taskStatus'],
+    });
+  })
+  .controller('gceTagImageStageCtrl', [
+    '$scope',
+    ($scope) => {
+      AccountService.listAccounts('gce').then((accounts) => ($scope.accounts = accounts));
+
+      $scope.stage.tags = $scope.stage.tags || {};
+      $scope.stage.cloudProvider = $scope.stage.cloudProvider || 'gce';
+
+      const initUpstreamStages = () => {
+        const upstreamDependencies = PipelineConfigService.getAllUpstreamDependencies(
+          $scope.pipeline,
+          $scope.stage,
+        ).filter((stage) => StageConstants.IMAGE_PRODUCING_STAGES.includes(stage.type));
+        $scope.consideredStages = new Map(upstreamDependencies.map((stage) => [stage.refId, stage.name]));
+      };
+      $scope.$watch('pipeline.stages', initUpstreamStages);
+    },
+  ]);

package/src/pipeline/stages/tagImage/tagImageExecutionDetails.html

@@ -0,0 +1,39 @@
+<div ng-controller="BaseExecutionDetailsCtrl">
+  <execution-details-section-nav sections="configSections"></execution-details-section-nav>
+  <div class="step-section-details" ng-if="detailsSection === 'tagImageConfig'">
+    <div class="row" ng-if="stage.context.targets">
+      <div class="col-md-12">
+        <dl class="dl-narrow dl-horizontal">
+          <dt if-multiple-providers>Provider</dt>
+          <dd if-multiple-providers>Google</dd>
+          <dt>Account</dt>
+          <dd>
+            <account-tag account="stage.context.credentials"></account-tag>
+          </dd>
+          <dt>Images</dt>
+          <dd ng-repeat="target in stage.context.targets">{{target.imageName}}</dd>
+        </dl>
+      </div>
+    </div>
+    <div class="row">
+      <div class="col-md-12">
+        <dl class="dl-narrow dl-horizontal">
+          <dt>Tags</dt>
+          <dd ng-repeat="(key, val) in stage.context.tags" ng-if="val !== null">{{key}} = {{val}}</dd>
+          <dt ng-if="stage.context.consideredStages">Stages</dt>
+          <dd ng-repeat="consideredStage in stage.context.consideredStages">
+            <stage-name stages="execution.stages" ref-id="consideredStage"></stage-name>
+          </dd>
+        </dl>
+      </div>
+    </div>
+
+    <stage-failure-message stage="stage" message="stage.failureMessage"></stage-failure-message>
+  </div>
+
+  <div class="step-section-details" ng-if="detailsSection === 'taskStatus'">
+    <div class="row">
+      <execution-step-details item="stage"></execution-step-details>
+    </div>
+  </div>
+</div>

package/src/pipeline/stages/tagImage/tagImageStage.html

@@ -0,0 +1,14 @@
+<div ng-controller="gceTagImageStageCtrl as tagImageStageCtrl" class="form-horizontal">
+  <stage-config-field label="Account">
+    <account-select-field component="stage" field="credentials" accounts="accounts" provider="'gce'" required>
+    </account-select-field>
+  </stage-config-field>
+  <stage-config-field label="Tags">
+    <map-editor model="stage.tags" allow-empty="true"></map-editor>
+  </stage-config-field>
+  <stage-config-field label="Stages (optional)" help-key="gce.tagImage.consideredStages" help-key-expand="true">
+    <div class="checkbox">
+      <checklist model="stage.consideredStages" items="consideredStages"></checklist>
+    </div>
+  </stage-config-field>
+</div>

package/src/regionSelectField.directive.html

@@ -0,0 +1,18 @@
+<div class="form-group">
+  <div class="col-md-{{labelColumns}} sm-label-right">Region</div>
+  <div class="col-md-{{fieldColumns || 7}}" ng-if="!account">(Select an account)</div>
+  <div class="col-md-{{fieldColumns || 7}}">
+    <select
+      class="form-control input-sm"
+      ng-if="account && !readOnly"
+      ng-model="component.region"
+      ng-change="onChange()"
+      required
+    >
+      <option ng-repeat="region in regions" value="{{region}}" ng-selected="component[field] === region">
+        {{region}}
+      </option>
+    </select>
+    <p ng-if="readOnly" class="form-control-static">{{component[field]}}</p>
+  </div>
+</div>

package/src/securityGroup/clone/cloneSecurityGroup.controller.js

@@ -0,0 +1,85 @@
+'use strict';
+
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import { AccountService, FirewallLabels } from '@spinnaker/core';
+import { GOOGLE_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUPMIXIN_CONTROLLER } from '../configure/ConfigSecurityGroupMixin.controller';
+
+export const GOOGLE_SECURITYGROUP_CLONE_CLONESECURITYGROUP_CONTROLLER =
+  'spinnaker.google.securityGroup.clone.controller';
+export const name = GOOGLE_SECURITYGROUP_CLONE_CLONESECURITYGROUP_CONTROLLER; // for backwards compatibility
+angular
+  .module(GOOGLE_SECURITYGROUP_CLONE_CLONESECURITYGROUP_CONTROLLER, [
+    GOOGLE_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUPMIXIN_CONTROLLER,
+  ])
+  .controller('gceCloneSecurityGroupController', [
+    '$scope',
+    '$uibModalInstance',
+    '$controller',
+    'securityGroup',
+    'application',
+    function ($scope, $uibModalInstance, $controller, securityGroup, application) {
+      const vm = this;
+
+      $scope.pages = {
+        location: require('../configure/createSecurityGroupProperties.html'),
+        targets: require('../configure/createSecurityGroupTargets.html'),
+        sourceFilters: require('../configure/createSecurityGroupSourceFilters.html'),
+        ingress: require('../configure/createSecurityGroupIngress.html'),
+      };
+
+      $scope.firewallLabel = FirewallLabels.get('Firewall');
+
+      angular.extend(
+        this,
+        $controller('gceConfigSecurityGroupMixin', {
+          $scope: $scope,
+          $uibModalInstance: $uibModalInstance,
+          application: application,
+          securityGroup: securityGroup,
+          mode: 'clone',
+        }),
+      );
+
+      AccountService.listAccounts('gce').then(function (accounts) {
+        $scope.accounts = accounts;
+        vm.accountUpdated();
+      });
+
+      securityGroup.sourceRanges = _.map(securityGroup.sourceRanges, function (sourceRange) {
+        return { value: sourceRange };
+      });
+
+      securityGroup.ipIngress = _.chain(securityGroup.ipIngressRules)
+        .map(function (rule) {
+          if (rule.portRanges && rule.portRanges.length > 0) {
+            return rule.portRanges.map(function (portRange) {
+              return {
+                type: rule.protocol,
+                startPort: portRange.startPort,
+                endPort: portRange.endPort,
+              };
+            });
+          } else {
+            return [
+              {
+                type: rule.protocol,
+              },
+            ];
+          }
+        })
+        .flatten()
+        .value();
+
+      securityGroup.backingData = {};
+
+      securityGroup.sourceTags = securityGroup.sourceTags || [];
+
+      vm.upsert = function () {
+        vm.mixinUpsert('Clone');
+      };
+
+      vm.initializeSecurityGroups();
+    },
+  ]);

package/src/securityGroup/clone/cloneSecurityGroup.html

@@ -0,0 +1,25 @@
+<ng-form name="form" novalidate class="gce-security-group-wizard">
+  <v2-modal-wizard heading="Clone {{firewallLabel}}" task-monitor="taskMonitor" dismiss="$dismiss()">
+    <v2-wizard-page key="Location" label="Location">
+      <ng-include src="pages.location"></ng-include>
+    </v2-wizard-page>
+    <v2-wizard-page key="Targets" label="Targets" done="true">
+      <ng-include src="pages.targets"></ng-include>
+    </v2-wizard-page>
+    <v2-wizard-page key="Source Filters" label="Source Filters" done="true">
+      <ng-include src="pages.sourceFilters"></ng-include>
+    </v2-wizard-page>
+    <v2-wizard-page key="Ingress" label="Ingress" done="true">
+      <ng-include src="pages.ingress"></ng-include>
+    </v2-wizard-page>
+  </v2-modal-wizard>
+  <div class="modal-footer">
+    <button class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+    <submit-button
+      is-disabled="form.$invalid || !wizard.isComplete() || state.submitting || !ctrl.isValid()"
+      submitting="state.submitting"
+      on-click="ctrl.upsert()"
+      is-new="isNew"
+    ></submit-button>
+  </div>
+</ng-form>

package/src/securityGroup/configure/ConfigSecurityGroupMixin.controller.js

@@ -0,0 +1,318 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import { module } from 'angular';
+import _ from 'lodash';
+
+import {
+  FirewallLabels,
+  ModalWizard,
+  NetworkReader,
+  SECURITY_GROUP_READER,
+  SecurityGroupWriter,
+  TaskMonitor,
+} from '@spinnaker/core';
+
+import { GCE_SECURITY_GROUP_HELP_TEXT_SERVICE } from '../securityGroupHelpText.service';
+
+import './securityGroup.configure.less';
+
+export const GOOGLE_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUPMIXIN_CONTROLLER =
+  'spinnaker.google.securityGroup.baseConfig.controller';
+export const name = GOOGLE_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUPMIXIN_CONTROLLER; // for backwards compatibility
+module(GOOGLE_SECURITYGROUP_CONFIGURE_CONFIGSECURITYGROUPMIXIN_CONTROLLER, [
+  UIROUTER_ANGULARJS,
+  SECURITY_GROUP_READER,
+  GCE_SECURITY_GROUP_HELP_TEXT_SERVICE,
+]).controller('gceConfigSecurityGroupMixin', [
+  '$scope',
+  '$state',
+  '$uibModalInstance',
+  'application',
+  'securityGroup',
+  'securityGroupReader',
+  'cacheInitializer',
+  'gceSecurityGroupHelpTextService',
+  'mode',
+  function (
+    $scope,
+    $state,
+    $uibModalInstance,
+    application,
+    securityGroup,
+    securityGroupReader,
+    cacheInitializer,
+    gceSecurityGroupHelpTextService,
+    mode,
+  ) {
+    const ctrl = this;
+
+    $scope.isNew = true;
+
+    $scope.state = {
+      submitting: false,
+      refreshingSecurityGroups: false,
+      removedRules: [],
+      infiniteScroll: {
+        numToAdd: 20,
+        currentItems: 20,
+      },
+      mode: mode,
+      target: null,
+      targetOptions: null,
+    };
+
+    $scope.wizard = ModalWizard;
+
+    ctrl.getTagHelpText = function (tag, tagType) {
+      return gceSecurityGroupHelpTextService.getHelpTextForTag(tag, tagType);
+    };
+
+    ctrl.addMoreItems = function () {
+      $scope.state.infiniteScroll.currentItems += $scope.state.infiniteScroll.numToAdd;
+    };
+
+    ctrl.registerHelpTextService = function () {
+      gceSecurityGroupHelpTextService.register(
+        application,
+        $scope.securityGroup.credentials || $scope.securityGroup.accountName,
+        securityGroup.network,
+      );
+    };
+
+    ctrl.initializeTargetOptions = function () {
+      const options = ['allowAllTraffic', 'specifyTags'];
+      if ($scope.state.mode === 'edit') {
+        $scope.state.targetOptions = options;
+      } else {
+        $scope.state.targetOptions = ['autoGenerate'].concat(options);
+      }
+    };
+
+    ctrl.initializeTarget = function () {
+      if ($scope.state.mode === 'create') {
+        $scope.state.target = 'autoGenerate';
+      } else {
+        if ($scope.securityGroup.targetTags && $scope.securityGroup.targetTags.length > 0) {
+          $scope.state.target = 'specifyTags';
+        } else {
+          $scope.state.target = 'allowAllTraffic';
+        }
+      }
+    };
+
+    ctrl.getTargetLabel = function (target) {
+      switch (target) {
+        case 'autoGenerate':
+          return 'Auto-generate target tag';
+        case 'allowAllTraffic':
+          return 'Allow traffic to all server groups';
+        case 'specifyTags':
+          return 'Specify target tags';
+        default:
+          return null;
+      }
+    };
+
+    ctrl.onTargetChange = function () {
+      switch ($scope.state.target) {
+        case 'autoGenerate':
+          $scope.securityGroup.targetTags = null;
+          break;
+        case 'allowAllTraffic':
+          $scope.securityGroup.targetTags = [];
+          break;
+        case 'specifyTags':
+          $scope.securityGroup.targetTags = $scope.securityGroup.targetTags || [];
+          break;
+        default:
+          break;
+      }
+    };
+
+    function onApplicationRefresh() {
+      // If the user has already closed the modal, do not navigate to the new details view
+      if ($scope.$$destroyed) {
+        return;
+      }
+      $uibModalInstance.close();
+      const newStateParams = {
+        name: $scope.securityGroup.name,
+        accountId: $scope.securityGroup.credentials || $scope.securityGroup.accountName,
+        region: 'global',
+        vpcId: $scope.securityGroup.vpcId,
+        provider: 'gce',
+      };
+      if (!$state.includes('**.firewallDetails')) {
+        $state.go('.firewallDetails', newStateParams);
+      } else {
+        $state.go('^.firewallDetails', newStateParams);
+      }
+    }
+
+    function onTaskComplete() {
+      application.securityGroups.refresh();
+      application.securityGroups.onNextRefresh($scope, onApplicationRefresh);
+    }
+
+    $scope.taskMonitor = new TaskMonitor({
+      application: application,
+      title: `Creating your ${FirewallLabels.get('firewall')}`,
+      modalInstance: $uibModalInstance,
+      onTaskComplete: onTaskComplete,
+    });
+
+    $scope.securityGroup = securityGroup;
+    ctrl.initializeTargetOptions();
+    ctrl.initializeTarget();
+    ctrl.onTargetChange();
+    ctrl.registerHelpTextService();
+
+    ctrl.upsert = function () {
+      $scope.taskMonitor.submit(function () {
+        return SecurityGroupWriter.upsertSecurityGroup($scope.securityGroup, application, 'Create');
+      });
+    };
+
+    ctrl.mixinUpsert = function (descriptor) {
+      $scope.taskMonitor.submit(function () {
+        const allowed = _.map($scope.securityGroup.ipIngress, function (ipIngressRule) {
+          const rule = {
+            ipProtocol: ipIngressRule.type,
+          };
+
+          if (ipIngressRule.startPort && ipIngressRule.endPort) {
+            rule.portRanges = [ipIngressRule.startPort + '-' + ipIngressRule.endPort];
+          }
+
+          return rule;
+        });
+
+        return SecurityGroupWriter.upsertSecurityGroup($scope.securityGroup, application, descriptor, {
+          cloudProvider: 'gce',
+          sourceRanges: _.uniq(_.map($scope.securityGroup.sourceRanges, 'value')),
+          targetTags: $scope.securityGroup.targetTags,
+          sourceTags: $scope.securityGroup.sourceTags,
+          allowed: allowed,
+          region: 'global',
+          network: $scope.securityGroup.network,
+        });
+      });
+    };
+
+    ctrl.accountUpdated = function () {
+      ctrl.initializeSecurityGroups();
+      ctrl.updateNetworks();
+      ctrl.updateName();
+    };
+
+    ctrl.refreshSecurityGroups = function () {
+      $scope.state.refreshingSecurityGroups = true;
+      return cacheInitializer.refreshCache('securityGroups').then(function () {
+        return ctrl.initializeSecurityGroups().then(function () {
+          $scope.state.refreshingSecurityGroups = false;
+        });
+      });
+    };
+
+    ctrl.initializeSecurityGroups = function () {
+      return securityGroupReader.getAllSecurityGroups().then(function (securityGroups) {
+        const account = $scope.securityGroup.credentials || $scope.securityGroup.accountName;
+
+        let existingGroups;
+        if (account) {
+          existingGroups = securityGroups[account].gce.global;
+        } else {
+          existingGroups = securityGroups;
+        }
+
+        $scope.existingSecurityGroupNames = _.map(existingGroups, 'name');
+      });
+    };
+
+    ctrl.cancel = function () {
+      $uibModalInstance.dismiss();
+    };
+
+    ctrl.updateNetworks = function () {
+      NetworkReader.listNetworksByProvider('gce').then(function (gceNetworks) {
+        const account = $scope.securityGroup.credentials || $scope.securityGroup.accountName;
+        $scope.securityGroup.backingData.networks = _(gceNetworks)
+          .filter((n) => n.account === account && !n.id.includes('/'))
+          .map((n) => n.id)
+          .value();
+      });
+    };
+
+    ctrl.getCurrentNamePattern = function () {
+      return /^[a-zA-Z0-9-]*$/;
+    };
+
+    ctrl.updateName = function () {
+      const securityGroup = $scope.securityGroup;
+      let name = application.name;
+      if (securityGroup.detail) {
+        name += '-' + securityGroup.detail;
+        name = _.trimEnd(name, '-');
+      }
+      securityGroup.name = name;
+      $scope.namePreview = name;
+    };
+
+    ctrl.namePattern = {
+      test: function (name) {
+        return ctrl.getCurrentNamePattern().test(name);
+      },
+    };
+
+    ctrl.addSourceCIDR = function (sourceRanges) {
+      sourceRanges.push({ value: '0.0.0.0/0' });
+    };
+
+    ctrl.removeSourceCIDR = function (sourceRanges, index) {
+      sourceRanges.splice(index, 1);
+    };
+
+    ctrl.addRule = function (ruleset) {
+      ruleset.push({
+        type: 'tcp',
+        startPort: 7001,
+        endPort: 7001,
+      });
+    };
+
+    ctrl.removeRule = function (ruleset, index) {
+      ruleset.splice(index, 1);
+    };
+
+    ctrl.dismissRemovedRules = function () {
+      $scope.state.removedRules = [];
+      ModalWizard.markClean('Ingress');
+      ModalWizard.markComplete('Ingress');
+    };
+
+    ctrl.isValid = function () {
+      return (
+        ($scope.state.target === 'specifyTags' ? $scope.securityGroup.targetTags.length > 0 : true) &&
+        $scope.securityGroup.ipIngress.length > 0 &&
+        ($scope.securityGroup.sourceTags.length > 0 || $scope.securityGroup.sourceRanges.length > 0)
+      );
+    };
+
+    ctrl.addTargetTag = function () {
+      $scope.securityGroup.targetTags.push('');
+    };
+
+    ctrl.removeTargetTag = function (index) {
+      $scope.securityGroup.targetTags.splice(index, 1);
+    };
+
+    ctrl.addSourceTag = function () {
+      $scope.securityGroup.sourceTags.push('');
+    };
+
+    ctrl.removeSourceTag = function (index) {
+      $scope.securityGroup.sourceTags.splice(index, 1);
+    };
+  },
+]);