@spinnaker/appengine 0.0.0-main-2

package/src/loadBalancer/details/details.controller.ts

@@ -0,0 +1,151 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController, IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalService } from 'angular-ui-bootstrap';
+import { cloneDeep } from 'lodash';
+
+import type { Application, ILoadBalancer, ILoadBalancerDeleteCommand } from '@spinnaker/core';
+import { ConfirmationModalService, LoadBalancerWriter } from '@spinnaker/core';
+import type { IAppengineLoadBalancer } from '../../domain';
+
+interface ILoadBalancerFromStateParams {
+  accountId: string;
+  region: string;
+  name: string;
+}
+
+class AppengineLoadBalancerDetailsController implements IController {
+  public state = { loading: true };
+  private loadBalancerFromParams: ILoadBalancerFromStateParams;
+  public loadBalancer: IAppengineLoadBalancer;
+  public dispatchRules: string[] = [];
+
+  public static $inject = ['$uibModal', '$state', '$scope', 'loadBalancer', 'app'];
+  constructor(
+    private $uibModal: IModalService,
+    private $state: StateService,
+    private $scope: IScope,
+    loadBalancer: ILoadBalancerFromStateParams,
+    private app: Application,
+  ) {
+    this.loadBalancerFromParams = loadBalancer;
+    this.app
+      .getDataSource('loadBalancers')
+      .ready()
+      .then(() => this.extractLoadBalancer());
+  }
+
+  public editLoadBalancer(): void {
+    this.$uibModal.open({
+      templateUrl: require('../configure/wizard/wizard.html'),
+      controller: 'appengineLoadBalancerWizardCtrl as ctrl',
+      size: 'lg',
+      resolve: {
+        application: () => this.app,
+        loadBalancer: () => cloneDeep(this.loadBalancer),
+        isNew: () => false,
+        forPipelineConfig: () => false,
+      },
+    });
+  }
+
+  public deleteLoadBalancer(): void {
+    const taskMonitor = {
+      application: this.app,
+      title: 'Deleting ' + this.loadBalancer.name,
+    };
+
+    const submitMethod = () => {
+      const loadBalancer: ILoadBalancerDeleteCommand = {
+        cloudProvider: this.loadBalancer.cloudProvider,
+        loadBalancerName: this.loadBalancer.name,
+        credentials: this.loadBalancer.account,
+      };
+      return LoadBalancerWriter.deleteLoadBalancer(loadBalancer, this.app);
+    };
+
+    ConfirmationModalService.confirm({
+      header: 'Really delete ' + this.loadBalancer.name + '?',
+      buttonText: 'Delete ' + this.loadBalancer.name,
+      body: this.getConfirmationModalBodyHtml(),
+      account: this.loadBalancer.account,
+      taskMonitorConfig: taskMonitor,
+      submitMethod,
+    });
+  }
+
+  public canDeleteLoadBalancer(): boolean {
+    return this.loadBalancer.name !== 'default';
+  }
+
+  private extractLoadBalancer(): void {
+    this.loadBalancer = this.app.getDataSource('loadBalancers').data.find((test: ILoadBalancer) => {
+      return test.name === this.loadBalancerFromParams.name && test.account === this.loadBalancerFromParams.accountId;
+    }) as IAppengineLoadBalancer;
+
+    if (this.loadBalancer) {
+      this.state.loading = false;
+      this.buildDispatchRules();
+      this.app.getDataSource('loadBalancers').onRefresh(this.$scope, () => this.extractLoadBalancer());
+    } else {
+      this.autoClose();
+    }
+  }
+
+  private buildDispatchRules(): void {
+    this.dispatchRules = [];
+    if (this.loadBalancer && this.loadBalancer.dispatchRules) {
+      this.loadBalancer.dispatchRules.forEach((rule) => {
+        if (rule.service === this.loadBalancer.name) {
+          this.dispatchRules.push(rule.domain + rule.path);
+        }
+      });
+    }
+  }
+
+  private getConfirmationModalBodyHtml(): string {
+    const serverGroupNames = this.loadBalancer.serverGroups.map((serverGroup) => serverGroup.name);
+    const hasAny = serverGroupNames ? serverGroupNames.length > 0 : false;
+    const hasMoreThanOne = serverGroupNames ? serverGroupNames.length > 1 : false;
+
+    // HTML accepted by the confirmationModalService is static (i.e., not managed by angular).
+    if (hasAny) {
+      if (hasMoreThanOne) {
+        const listOfServerGroupNames = serverGroupNames.map((name) => `<li>${name}</li>`).join('');
+        return `<div class="alert alert-warning">
+            <p>
+              Deleting <b>${this.loadBalancer.name}</b> will destroy the following server groups:
+              <ul>
+                ${listOfServerGroupNames}
+              </ul>
+            </p>
+          </div>
+        `;
+      } else {
+        return `<div class="alert alert-warning">
+            <p>
+              Deleting <b>${this.loadBalancer.name}</b> will destroy <b>${serverGroupNames[0]}</b>.
+            </p>
+          </div>
+        `;
+      }
+    } else {
+      return null;
+    }
+  }
+
+  private autoClose(): void {
+    if (this.$scope.$$destroyed) {
+      return;
+    } else {
+      this.$state.params.allowModalToStayOpen = true;
+      this.$state.go('^', null, { location: 'replace' });
+    }
+  }
+}
+
+export const APPENGINE_LOAD_BALANCER_DETAILS_CTRL = 'spinnaker.appengine.loadBalancerDetails.controller';
+module(APPENGINE_LOAD_BALANCER_DETAILS_CTRL, []).controller(
+  'appengineLoadBalancerDetailsCtrl',
+  AppengineLoadBalancerDetailsController,
+);

package/src/loadBalancer/details/details.html

@@ -0,0 +1,102 @@
+<div class="details-panel">
+  <div ng-if="ctrl.state.loading" class="header">
+    <div class="close-button">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <div class="horizontal center middle">
+      <loading-spinner size="'small'"></loading-spinner>
+    </div>
+  </div>
+
+  <div ng-if="!ctrl.state.loading" class="header">
+    <div class="close-button">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <div class="header-text horizontal middle">
+      <i class="fa icon-sitemap"></i>
+      <h3 class="horizontal middle space-between flex-1" select-on-dbl-click>{{ctrl.loadBalancer.name}}</h3>
+    </div>
+    <div>
+      <div class="actions">
+        <div class="dropdown" uib-dropdown dropdown-append-to-body>
+          <button type="button" class="btn btn-sm btn-primary dropdown-toggle" uib-dropdown-toggle>
+            Load Balancer Actions <span class="caret"></span>
+          </button>
+          <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+            <li><a href ng-click="ctrl.editLoadBalancer()">Edit Load Balancer</a></li>
+            <li ng-if="ctrl.canDeleteLoadBalancer()">
+              <a href ng-click="ctrl.deleteLoadBalancer()">Delete Load Balancer</a>
+            </li>
+            <li
+              ng-if="!ctrl.canDeleteLoadBalancer()"
+              uib-tooltip="You cannot delete a default service."
+              class="disabled"
+            >
+              <a href>Delete Load Balancer</a>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div ng-if="!ctrl.state.loading" class="content">
+    <collapsible-section heading="Load Balancer Details" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt>In</dt>
+        <dd><account-tag account="ctrl.loadBalancer.account" pad="right"></account-tag></dd>
+        <dt>Region</dt>
+        <dd>{{ctrl.loadBalancer.region}}</dd>
+        <dt ng-if="ctrl.loadBalancer.serverGroups.length">Server Groups</dt>
+        <dd ng-if="ctrl.loadBalancer.serverGroups.length">
+          <ul>
+            <li ng-repeat="serverGroup in ctrl.loadBalancer.serverGroups | orderBy: ['isDisabled', '-name']">
+              <a
+                ui-sref="^.serverGroup({region: serverGroup.region,
+                                         accountId: serverGroup.account,
+                                         serverGroup: serverGroup.name,
+                                         provider: 'appengine'})"
+              >
+                {{serverGroup.name}}
+              </a>
+            </li>
+          </ul>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Status" expanded="true">
+      <health-counts class="pull-left" container="ctrl.loadBalancer.instanceCounts"></health-counts>
+    </collapsible-section>
+    <collapsible-section heading="Traffic Split" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt ng-if="ctrl.loadBalancer.split.shardBy">Shard By</dt>
+        <dd ng-if="ctrl.loadBalancer.split.shardBy">
+          {{ctrl.loadBalancer.split.shardBy}}
+          <help-field
+            key="appengine.loadBalancer.shardBy.{{ctrl.loadBalancer.split.shardBy.toLowerCase()}}"
+          ></help-field>
+        </dd>
+        <hr ng-if="ctrl.loadBalancer.split.shardBy" />
+        <ul>
+          <li ng-repeat="(serverGroup, percent) in ctrl.loadBalancer.split.allocations">
+            {{serverGroup}}:<span class="pull-right">{{percent | decimalToPercent}}</span>
+          </li>
+        </ul>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="DNS" expanded="true">
+      <dl class="dl-narrow">
+        <appengine-component-url-details component="ctrl.loadBalancer"></appengine-component-url-details>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Dispatch Rules" expanded="true" ng-if="ctrl.dispatchRules.length > 0">
+      <dl class="dl-horizontal dl-narrow">
+        <span ng-repeat-start="rule in ctrl.dispatchRules">{{rule}}</span><br ng-repeat-end />
+      </dl>
+    </collapsible-section>
+  </div>
+</div>

package/src/loadBalancer/loadBalancer.module.ts

@@ -0,0 +1,21 @@
+import { module } from 'angular';
+
+import { APPENGINE_LOAD_BALANCER_ADVANCED_SETTINGS } from './configure/wizard/advancedSettings.component';
+import { APPENGINE_ALLOCATION_CONFIGURATION_ROW } from './configure/wizard/allocationConfigurationRow.component';
+import { APPENGINE_LOAD_BALANCER_BASIC_SETTINGS } from './configure/wizard/basicSettings.component';
+import { APPENGINE_STAGE_ALLOCATION_CONFIGURATION_ROW } from './configure/wizard/stageAllocationConfigurationRow.component';
+import { APPENGINE_LOAD_BALANCER_WIZARD_CTRL } from './configure/wizard/wizard.controller';
+import { APPENGINE_LOAD_BALANCER_DETAILS_CTRL } from './details/details.controller';
+import { APPENGINE_LOAD_BALANCER_TRANSFORMER } from './transformer';
+
+export const APPENGINE_LOAD_BALANCER_MODULE = 'spinnaker.appengine.loadBalancer.module';
+
+module(APPENGINE_LOAD_BALANCER_MODULE, [
+  APPENGINE_ALLOCATION_CONFIGURATION_ROW,
+  APPENGINE_LOAD_BALANCER_DETAILS_CTRL,
+  APPENGINE_LOAD_BALANCER_ADVANCED_SETTINGS,
+  APPENGINE_LOAD_BALANCER_BASIC_SETTINGS,
+  APPENGINE_LOAD_BALANCER_TRANSFORMER,
+  APPENGINE_LOAD_BALANCER_WIZARD_CTRL,
+  APPENGINE_STAGE_ALLOCATION_CONFIGURATION_ROW,
+]);

package/src/loadBalancer/transformer.ts

@@ -0,0 +1,170 @@
+import { module } from 'angular';
+import { camelCase, chain, cloneDeep, filter, get, has, reduce } from 'lodash';
+
+import type {
+  Application,
+  IInstance,
+  IInstanceCounts,
+  ILoadBalancer,
+  ILoadBalancerUpsertCommand,
+  IServerGroup,
+} from '@spinnaker/core';
+import type { IAppengineLoadBalancer, IAppengineTrafficSplit, ShardBy } from '../domain/index';
+
+export interface IAppengineAllocationDescription {
+  serverGroupName?: string;
+  target?: string;
+  cluster?: string;
+  allocation: number;
+  locatorType: 'fromExisting' | 'targetCoordinate' | 'text';
+}
+
+export interface IAppengineTrafficSplitDescription {
+  shardBy: ShardBy;
+  allocationDescriptions: IAppengineAllocationDescription[];
+}
+
+export class AppengineLoadBalancerUpsertDescription implements ILoadBalancerUpsertCommand, IAppengineLoadBalancer {
+  public credentials: string;
+  public account: string;
+  public loadBalancerName: string;
+  public name: string;
+  public splitDescription: IAppengineTrafficSplitDescription;
+  public split?: IAppengineTrafficSplit;
+  public migrateTraffic: boolean;
+  public region: string;
+  public cloudProvider: string;
+  public serverGroups?: any[];
+
+  public static convertTrafficSplitToTrafficSplitDescription(
+    split: IAppengineTrafficSplit,
+  ): IAppengineTrafficSplitDescription {
+    const allocationDescriptions = reduce(
+      split.allocations,
+      (acc: IAppengineAllocationDescription[], allocation: number, serverGroupName: string) => {
+        return acc.concat({ serverGroupName, allocation, locatorType: 'fromExisting' });
+      },
+      [],
+    );
+
+    return { shardBy: split.shardBy, allocationDescriptions };
+  }
+
+  constructor(loadBalancer: IAppengineLoadBalancer) {
+    this.credentials = loadBalancer.account || loadBalancer.credentials;
+    this.account = this.credentials;
+    this.cloudProvider = loadBalancer.cloudProvider;
+    this.loadBalancerName = loadBalancer.name;
+    this.name = loadBalancer.name;
+    this.region = loadBalancer.region;
+    this.migrateTraffic = loadBalancer.migrateTraffic || false;
+    this.serverGroups = loadBalancer.serverGroups;
+  }
+
+  public mapAllocationsToDecimals() {
+    this.splitDescription.allocationDescriptions.forEach((description) => {
+      description.allocation = description.allocation / 100;
+    });
+  }
+
+  public mapAllocationsToPercentages() {
+    this.splitDescription.allocationDescriptions.forEach((description) => {
+      // An allocation percent has at most one decimal place.
+      description.allocation = Math.round(description.allocation * 1000) / 10;
+    });
+  }
+}
+
+export class AppengineLoadBalancerTransformer {
+  public static $inject = ['$q'];
+  constructor(private $q: ng.IQService) {}
+
+  public normalizeLoadBalancer(loadBalancer: ILoadBalancer): PromiseLike<ILoadBalancer> {
+    loadBalancer.provider = loadBalancer.type;
+    loadBalancer.instanceCounts = this.buildInstanceCounts(loadBalancer.serverGroups);
+    loadBalancer.instances = [];
+    loadBalancer.serverGroups.forEach((serverGroup) => {
+      serverGroup.account = loadBalancer.account;
+      serverGroup.region = loadBalancer.region;
+
+      if (serverGroup.detachedInstances) {
+        serverGroup.detachedInstances = (serverGroup.detachedInstances as any).map((id: string) => ({ id }));
+      }
+      serverGroup.instances = serverGroup.instances
+        .concat(serverGroup.detachedInstances || [])
+        .map((instance: any) => this.transformInstance(instance, loadBalancer));
+    });
+
+    const activeServerGroups = filter(loadBalancer.serverGroups, { isDisabled: false });
+    loadBalancer.instances = chain(activeServerGroups).map('instances').flatten().value() as IInstance[];
+    return this.$q.resolve(loadBalancer);
+  }
+
+  public convertLoadBalancerForEditing(
+    loadBalancer: IAppengineLoadBalancer,
+    application: Application,
+  ): PromiseLike<IAppengineLoadBalancer> {
+    return application
+      .getDataSource('loadBalancers')
+      .ready()
+      .then(() => {
+        const upToDateLoadBalancer = application
+          .getDataSource('loadBalancers')
+          .data.find((candidate: ILoadBalancer) => {
+            return (
+              candidate.name === loadBalancer.name &&
+              (candidate.account === loadBalancer.account || candidate.account === loadBalancer.credentials)
+            );
+          });
+
+        if (upToDateLoadBalancer) {
+          loadBalancer.serverGroups = cloneDeep(upToDateLoadBalancer.serverGroups);
+        }
+        return loadBalancer;
+      });
+  }
+
+  public convertLoadBalancerToUpsertDescription(
+    loadBalancer: IAppengineLoadBalancer,
+  ): AppengineLoadBalancerUpsertDescription {
+    return new AppengineLoadBalancerUpsertDescription(loadBalancer);
+  }
+
+  private buildInstanceCounts(serverGroups: IServerGroup[]): IInstanceCounts {
+    const instanceCounts: IInstanceCounts = chain(serverGroups)
+      .map('instances')
+      .flatten()
+      .reduce(
+        (acc: IInstanceCounts, instance: any) => {
+          if (has(instance, 'health.state')) {
+            acc[camelCase(instance.health.state)]++;
+          }
+          return acc;
+        },
+        { up: 0, down: 0, outOfService: 0, succeeded: 0, failed: 0, starting: 0, unknown: 0 },
+      )
+      .value();
+
+    instanceCounts.outOfService += chain(serverGroups).map('detachedInstances').flatten().value().length;
+    return instanceCounts;
+  }
+
+  private transformInstance(instance: any, loadBalancer: ILoadBalancer) {
+    instance.provider = loadBalancer.type;
+    instance.account = loadBalancer.account;
+    instance.region = loadBalancer.region;
+    instance.loadBalancers = [loadBalancer.name];
+    const health = instance.health || {};
+    instance.healthState = get(instance, 'health.state') || 'OutOfService';
+    instance.health = [health];
+
+    return instance as IInstance;
+  }
+}
+
+export const APPENGINE_LOAD_BALANCER_TRANSFORMER = 'spinnaker.appengine.loadBalancer.transformer.service';
+
+module(APPENGINE_LOAD_BALANCER_TRANSFORMER, []).service(
+  'appengineLoadBalancerTransformer',
+  AppengineLoadBalancerTransformer,
+);

package/src/logo/appengine.icon.svg

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 18.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="128px"
+	 height="128px" viewBox="15 15 90 90" xml:space="preserve">
+<filter id="invert">
+  <feColorMatrix in="SourceGraphic" type="matrix" values="-1 0 0 0 1
+                                                          0 -1 0 0 1
+                                                          0 0 -1 0 1
+                                                          0 0 0 1 0"/>
+</filter>
+<g id="art" filter="url(#invert)">
+	<g>
+		<path style="fill:#FFFFFF;" d="M63.9988,40.9577c-12.7278,0-23.0452,10.3167-23.0452,23.0464
+			c0,12.726,10.3174,23.0463,23.0452,23.0463c12.7273,0,23.0446-10.3203,23.0446-23.0463
+			C87.0434,51.2744,76.7261,40.9577,63.9988,40.9577 M63.9988,81.4887c-9.6584,0-17.4876-7.8286-17.4876-17.4846
+			c0-9.6584,7.8291-17.4877,17.4876-17.4877c9.6578,0,17.4858,7.8292,17.4858,17.4877
+			C81.4846,73.6601,73.6566,81.4887,63.9988,81.4887"/>
+		<path style="fill:#FFFFFF;" d="M100.1431,61.274l-9.6079-3.0195c0.3997,1.8539,0.615,3.7759,0.615,5.7478
+			c0,1.3791-0.1047,2.7337-0.3021,4.0569h9.295c0.8587-0.2515,1.4327-0.7846,1.4327-1.5765v-3.6345
+			C101.5759,62.0575,101.0018,61.5094,100.1431,61.274"/>
+		<path style="fill:#FFFFFF;" d="M63.9923,36.8497c1.9303,0,3.8119,0.2046,5.6285,0.5884l-3.4443-9.5729
+			c-0.2515-0.8606-0.7852-1.434-1.5765-1.434h-1.4392c-0.7913,0-1.3407,0.5734-1.5761,1.434l-2.9924,9.5236
+			C60.3372,37.0368,62.1425,36.8497,63.9923,36.8497"/>
+		<path style="fill:#FFFFFF;" d="M36.8468,64.0023c0-1.9719,0.2154-3.8932,0.6145-5.7478l-9.6073,3.0195
+			c-0.8587,0.2354-1.4322,0.7835-1.4322,1.5754v3.6344c0,0.7907,0.5735,1.3238,1.4322,1.5753h9.2955
+			C36.9515,66.7366,36.8468,65.3814,36.8468,64.0023"/>
+		<path style="fill:#FFFFFF;" d="M72.2276,56.4819l-2.1802,2.1794v-0.0048c-1.5651-1.5639-3.6549-2.4274-5.8687-2.4274
+			c-2.2192,0-4.303,0.8659-5.8704,2.4322c-3.2362,3.2355-3.2362,8.5037,0,11.7399l-2.1802,2.1783
+			c2.0627,2.0609,4.9096,3.3383,8.0483,3.3383c6.2803,0,11.3896-5.1081,11.3896-11.3895
+			C75.566,61.3883,74.289,58.5421,72.2276,56.4819 M67.7284,67.7342c-1.0278,1.0302-2.3799,1.5459-3.7284,1.5459
+			c-1.3526,0-2.7012-0.5156-3.7313-1.5459c-2.0616-2.0615-2.0616-5.4018,0-7.4639c1.0301-1.0314,2.3787-1.544,3.7313-1.544
+			c1.3485,0,2.7006,0.5127,3.7284,1.544C69.79,62.3312,69.79,65.6727,67.7284,67.7342"/>
+	</g>
+</g>
+<g id="Guides" style="display:none;">
+</g>
+</svg>

package/src/logo/appengine.logo.less

@@ -0,0 +1,6 @@
+.cloud-provider-logo {
+  .icon-appengine {
+    mask-image: url('appengine.icon.svg');
+    background-color: #4285f4;
+  }
+}

package/src/pipeline/pipeline.module.ts

@@ -0,0 +1,20 @@
+import { module } from 'angular';
+
+import { APPENGINE_DESTROY_ASG_STAGE } from './stages/destroyAsg/appengineDestroyAsgStage';
+import { APPENGINE_DISABLE_ASG_STAGE } from './stages/disableAsg/appengineDisableAsgStage';
+import { APPENGINE_EDIT_LOAD_BALANCER_STAGE } from './stages/editLoadBalancer/appengineEditLoadBalancerStage';
+import { APPENGINE_ENABLE_ASG_STAGE } from './stages/enableAsg/appengineEnableAsgStage';
+import { APPENGINE_SHRINK_CLUSTER_STAGE } from './stages/shrinkCluster/appengineShrinkClusterStage';
+import { APPENGINE_START_SERVER_GROUP_STAGE } from './stages/startServerGroup/appengineStartServerGroupStage';
+import { APPENGINE_STOP_SERVER_GROUP_STAGE } from './stages/stopServerGroup/appengineStopServerGroupStage';
+
+export const APPENGINE_PIPELINE_MODULE = 'spinnaker.appengine.pipeline.module';
+module(APPENGINE_PIPELINE_MODULE, [
+  APPENGINE_DESTROY_ASG_STAGE,
+  APPENGINE_DISABLE_ASG_STAGE,
+  APPENGINE_EDIT_LOAD_BALANCER_STAGE,
+  APPENGINE_ENABLE_ASG_STAGE,
+  APPENGINE_SHRINK_CLUSTER_STAGE,
+  APPENGINE_START_SERVER_GROUP_STAGE,
+  APPENGINE_STOP_SERVER_GROUP_STAGE,
+]);

package/src/pipeline/stages/appengineStage.controller.ts

@@ -0,0 +1,45 @@
+import type { IController } from 'angular';
+
+import { AccountService, StageConstants } from '@spinnaker/core';
+import { AppengineHealth } from '../../common/appengineHealth';
+import type { IAppengineAccount, IAppengineStageScope } from '../../domain';
+
+export class AppengineStageCtrl implements IController {
+  public static $inject = ['$scope'];
+  constructor(protected $scope: IAppengineStageScope) {
+    $scope.platformHealth = AppengineHealth.PLATFORM;
+  }
+
+  public setStageRegion(): void {
+    const selected = this.$scope.accounts.find((account) => account.name === this.$scope.stage.credentials);
+    if (selected && selected.name) {
+      AccountService.getAccountDetails(selected.name).then((accountDetails: IAppengineAccount) => {
+        this.$scope.stage.region = accountDetails.region;
+      });
+    }
+  }
+
+  protected setStageCloudProvider(): void {
+    this.$scope.stage.cloudProvider = 'appengine';
+  }
+
+  protected setAccounts(): PromiseLike<void> {
+    return AccountService.listAccounts('appengine').then((accounts: IAppengineAccount[]) => {
+      this.$scope.accounts = accounts;
+    });
+  }
+
+  protected setTargets(): void {
+    this.$scope.targets = StageConstants.TARGET_LIST;
+
+    if (!this.$scope.stage.target) {
+      this.$scope.stage.target = this.$scope.targets[0].val;
+    }
+  }
+
+  protected setStageCredentials(): void {
+    if (!this.$scope.stage.credentials && this.$scope.application.defaultCredentials.appengine) {
+      this.$scope.stage.credentials = this.$scope.application.defaultCredentials.appengine;
+    }
+  }
+}