@spinnaker/oracle 0.0.0-main-2

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

@@ -0,0 +1,229 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { AccountService, NetworkReader, SECURITY_GROUP_READER, SubnetReader } from '@spinnaker/core';
+import { OracleProviderSettings } from '../../oracle.settings';
+
+export const ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE =
+  'spinnaker.oracle.serverGroup.configure.configuration.service';
+export const name = ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE; // for backwards compatibility
+module(ORACLE_SERVERGROUP_CONFIGURE_SERVERGROUPCONFIGURATION_SERVICE, [SECURITY_GROUP_READER]).factory(
+  'oracleServerGroupConfigurationService',
+  [
+    '$q',
+    'oracleImageReader',
+    'securityGroupReader',
+    function ($q, oracleImageReader, securityGroupReader) {
+      const oracle = 'oracle';
+
+      const getShapes = (image) => {
+        if (!image || !image.compatibleShapes) {
+          return [];
+        }
+        return image.compatibleShapes.map((shape) => {
+          return { name: shape };
+        });
+      };
+
+      const loadAndSelectRegions = (command, backingData) => {
+        if (command.account) {
+          const selectedAccountDetails = backingData.credentialsKeyedByAccount[command.account];
+          if (!selectedAccountDetails) {
+            return;
+          }
+          backingData.filtered.regions = _.map(selectedAccountDetails.regions, (region) => {
+            return { name: region.name };
+          });
+          if (selectedAccountDetails) {
+            command.region = selectedAccountDetails.region;
+          }
+        }
+      };
+
+      const loadAvailabilityDomains = (command) => {
+        if (command.account && command.region) {
+          AccountService.getAvailabilityZonesForAccountAndRegion(oracle, command.account, command.region).then(
+            (availDoms) => {
+              if (availDoms) {
+                command.backingData.filtered.availabilityDomains = availDoms.map((av) => {
+                  return { name: av };
+                });
+              } else {
+                command.backingData.filtered.availabilityDomains = [];
+                command.availabilityDomain = null;
+              }
+            },
+          );
+        }
+      };
+
+      const loadLoadBalancers = (command) => {
+        if (command.account && command.region) {
+          command.backingData.filtered.loadBalancers = command.backingData.loadBalancers.filter(function (lb) {
+            return lb.region === command.region && lb.account === command.account;
+          });
+        }
+      };
+
+      function configureCommand(application, command) {
+        const defaults = command || {};
+        const defaultCredentials =
+          defaults.account || application.defaultCredentials.oracle || OracleProviderSettings.defaults.account;
+        const defaultRegion =
+          defaults.region || application.defaultRegions.oracle || OracleProviderSettings.defaults.region;
+
+        return $q
+          .all([
+            AccountService.getCredentialsKeyedByAccount(oracle),
+            NetworkReader.listNetworksByProvider(oracle),
+            SubnetReader.listSubnetsByProvider(oracle),
+            securityGroupReader.getAllSecurityGroups(),
+            loadImages(),
+            AccountService.getAvailabilityZonesForAccountAndRegion(oracle, defaultCredentials, defaultRegion),
+          ])
+          .then(function ([credentialsKeyedByAccount, networks, subnets, securityGroups, images, availDomains]) {
+            const backingData = {
+              credentialsKeyedByAccount,
+              networks,
+              subnets,
+              securityGroups,
+              images,
+              availDomains,
+            };
+
+            backingData.accounts = _.keys(backingData.credentialsKeyedByAccount);
+            backingData.filtered = {};
+            loadAndSelectRegions(command, backingData);
+            backingData.filtered.availabilityDomains = _.map(backingData.availDomains, function (zone) {
+              return { name: zone };
+            });
+
+            backingData.filterSubnets = function () {
+              if (command.vpcId && command.availabilityDomain) {
+                return _.filter(backingData.subnets, {
+                  vcnId: command.vpcId,
+                  availabilityDomain: command.availabilityDomain,
+                });
+              }
+              return backingData.subnets;
+            };
+
+            backingData.loadBalancers = application.loadBalancers.data;
+
+            backingData.accountOnChange = function () {
+              loadAndSelectRegions(command, command.backingData);
+              loadAvailabilityDomains(command);
+              loadLoadBalancers(command);
+            };
+
+            backingData.regionOnChange = function () {
+              loadAvailabilityDomains(command);
+              loadLoadBalancers(command);
+            };
+
+            backingData.availabilityDomainOnChange = function () {
+              command.subnetId = null;
+              backingData.seclists = null;
+            };
+
+            backingData.vpcOnChange = function () {
+              command.subnetId = null;
+              backingData.seclists = null;
+            };
+
+            backingData.subnetOnChange = function () {
+              const subnet = _.find(backingData.subnets, { id: command.subnetId });
+              const mySecGroups = backingData.securityGroups[command.account][oracle][command.region];
+              const secLists = [];
+              _.forEach(subnet.securityListIds, function (sid) {
+                const sgRef = _.find(mySecGroups, { id: sid });
+                securityGroupReader
+                  .getSecurityGroupDetails(
+                    command.application,
+                    command.account,
+                    oracle,
+                    command.region,
+                    command.vpcId,
+                    sgRef.name,
+                  )
+                  .then(function (sgd) {
+                    secLists.push(sgd);
+                    backingData.seclists = secLists;
+                  });
+              });
+            };
+
+            backingData.findBackendSetsByLoadBalancerId = (loadBalancerId) => {
+              const lb = backingData.filtered.loadBalancers.find((lb) => lb.id === loadBalancerId);
+              if (lb && lb.backendSets) {
+                //reduce the backendSets object to an array. The object is keyed by the backendSet name
+                const bsetArray = [];
+                Object.keys(lb.backendSets).reduce((arr, bsetName) => {
+                  const bset = lb.backendSets[bsetName];
+                  bset['name'] = bsetName;
+                  arr.push(bset);
+                  return arr;
+                }, bsetArray);
+                return bsetArray;
+              } else {
+                return [];
+              }
+            };
+
+            backingData.findLoadBalListenersByBackendSetName = (loadBalancerId, backendSetName) => {
+              const lb = backingData.filtered.loadBalancers.find((lb) => lb.id === loadBalancerId);
+              if (lb && lb.listeners) {
+                return Object.keys(lb.listeners)
+                  .filter((lisName) => lb.listeners[lisName].defaultBackendSetName === backendSetName)
+                  .map((lisName) => lb.listeners[lisName]);
+              } else {
+                return [];
+              }
+            };
+
+            backingData.loadBalancerOnChange = () => {
+              if (command.loadBalancerId) {
+                backingData.filtered.backendSets = backingData.findBackendSetsByLoadBalancerId(command.loadBalancerId);
+              } else {
+                //no backend set name should be set if no load balancer id is set
+                command.backendSetName = undefined;
+                backingData.backendSetOnChange();
+                backingData.filtered.backendSets = [];
+              }
+            };
+
+            backingData.backendSetOnChange = () => {
+              backingData.filtered.listeners =
+                command.loadBalancerId && command.backendSetName
+                  ? backingData.findLoadBalListenersByBackendSetName(command.loadBalancerId, command.backendSetName)
+                  : [];
+            };
+
+            backingData.filtered.images = backingData.images;
+            const shapesMap = {};
+            _.forEach(backingData.filtered.images, (image) => {
+              shapesMap[image.id] = getShapes(image);
+            });
+            backingData.filtered.shapes = shapesMap;
+            backingData.filtered.allShapes = _.uniqBy(_.flatten(_.values(shapesMap)), 'name');
+            command.backingData = backingData;
+            if (command.account) {
+              loadLoadBalancers(command);
+              backingData.loadBalancerOnChange();
+              backingData.backendSetOnChange();
+            }
+          });
+      }
+
+      function loadImages() {
+        return oracleImageReader.findImages({ provider: oracle });
+      }
+
+      return {
+        configureCommand: configureCommand,
+      };
+    },
+  ],
+);

package/src/serverGroup/configure/wizard/advancedSettings/advancedSettings.html

@@ -0,0 +1,13 @@
+<div class="form-group">
+  <div class="col-md-5 sm-label-right"><b>Key Name</b></div>
+  <div class="col-md-6">
+    <ui-select ng-model="$ctrl.command.keyPair" class="form-control input-sm" required on-select="$ctrl.fieldChanged()">
+      <ui-select-match>{{$select.selected}}</ui-select-match>
+      <ui-select-choices
+        repeat="regionalKeyPair in $ctrl.command.backingData.filtered.keyPairs | filter: $select.search"
+      >
+        <span ng-bind-html="regionalKeyPair"></span>
+      </ui-select-choices>
+    </ui-select>
+  </div>
+</div>

package/src/serverGroup/configure/wizard/basicSettings/basicSettings.controller.js

@@ -0,0 +1,35 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import * as angular from 'angular';
+import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
+
+import { IMAGE_READER } from '@spinnaker/core';
+
+export const ORACLE_SERVERGROUP_CONFIGURE_WIZARD_BASICSETTINGS_BASICSETTINGS_CONTROLLER =
+  'spinnaker.oracle.serverGroup.configure.wizard.basicSettings.controller';
+export const name = ORACLE_SERVERGROUP_CONFIGURE_WIZARD_BASICSETTINGS_BASICSETTINGS_CONTROLLER; // for backwards compatibility
+angular
+  .module(ORACLE_SERVERGROUP_CONFIGURE_WIZARD_BASICSETTINGS_BASICSETTINGS_CONTROLLER, [
+    UIROUTER_ANGULARJS,
+    ANGULAR_UI_BOOTSTRAP,
+    IMAGE_READER,
+  ])
+  .controller('oracleServerGroupBasicSettingsCtrl', [
+    '$scope',
+    '$state',
+    '$uibModalStack',
+    '$controller',
+    'imageReader',
+    function ($scope, $state, $uibModalStack, $controller, imageReader) {
+      angular.extend(
+        this,
+        $controller('BasicSettingsMixin', {
+          $scope: $scope,
+          imageReader: imageReader,
+          $uibModalStack: $uibModalStack,
+          $state: $state,
+        }),
+      );
+    },
+  ]);

package/src/serverGroup/configure/wizard/basicSettings/basicSettings.html

@@ -0,0 +1,134 @@
+<div class="container-fluid form-horizontal" ng-controller="oracleServerGroupBasicSettingsCtrl as basicSettingsCtrl">
+  <div class="modal-body">
+    <div class="form-group">
+      <div class="col-md-3 sm-label-right">Account</div>
+      <div class="col-md-7">
+        <account-select-field
+          required
+          read-only="command.viewState.readOnlyFields.credentials"
+          component="command"
+          field="account"
+          accounts="command.backingData.accounts"
+          provider="'oracle'"
+          on-change="command.backingData.accountOnChange()"
+        ></account-select-field>
+      </div>
+    </div>
+    <region-select-field
+      label-columns="3"
+      component="command"
+      field="region"
+      account="command.account"
+      provider="'oracle'"
+      regions="command.backingData.filtered.regions"
+      on-change="command.backingData.regionOnChange()"
+    ></region-select-field>
+    <!-- VCN Selection (which will then filter subnets) -->
+    <div class="form-group">
+      <div class="col-md-3 sm-label-right">VCN</div>
+      <div class="col-md-9">
+        <ui-select
+          class="form-control input-sm"
+          required
+          ng-model="command.vpcId"
+          ng-change="command.backingData.vpcOnChange()"
+        >
+          <ui-select-match placeholder="Select VCN">{{$select.selected.name}}</ui-select-match>
+          <ui-select-choices repeat="network.id as network in command.backingData.networks">
+            <span ng-bind-html="network.name | highlight: $select.search"></span>
+          </ui-select-choices>
+        </ui-select>
+      </div>
+    </div>
+
+    <div class="form-group" ng-show="command.vpcId">
+      <div class="col-md-3 sm-label-right">Availability Domain</div>
+      <div class="col-md-7">
+        <ui-select
+          class="form-control input-sm"
+          required
+          ng-model="command.availabilityDomain"
+          ng-change="command.backingData.availabilityDomainOnChange()"
+        >
+          <ui-select-match placeholder="Select AD">{{$select.selected.name}}</ui-select-match>
+          <ui-select-choices
+            repeat="availabilityDomain.name as availabilityDomain in command.backingData.filtered.availabilityDomains"
+          >
+            <span ng-bind-html="availabilityDomain.name"></span>
+          </ui-select-choices>
+        </ui-select>
+      </div>
+    </div>
+
+    <!-- Subnet selection -->
+    <div class="form-group" ng-show="command.availabilityDomain">
+      <div class="col-md-3 sm-label-right">Subnet</div>
+      <div class="col-md-9">
+        <ui-select
+          class="form-control input-sm"
+          required
+          ng-model="command.subnetId"
+          ng-change="command.backingData.subnetOnChange()"
+        >
+          <ui-select-match placeholder="Select subnet">{{$select.selected.name}}</ui-select-match>
+          <ui-select-choices repeat="subnet.id as subnet in command.backingData.filterSubnets()">
+            <span ng-bind-html="subnet.name | highlight: $select.search"></span>
+          </ui-select-choices>
+        </ui-select>
+      </div>
+    </div>
+
+    <div class="form-group small" style="margin-top: 20px" ng-show="command.backingData.seclists">
+      <div class="col-md-3 sm-label-right">Effective Security Lists</div>
+      <div class="col-md-9">
+        <p>Security Lists attached to selected subnet:</p>
+        <ul ng-repeat="seclist in command.backingData.seclists">
+          <div class="sm-label-left">{{seclist.name}}</div>
+          <div ng-repeat="rule in seclist.inboundRules">
+            <li ng-repeat="range in rule.portRanges">{{rule.protocol}}: {{range.startPort}} -> {{range.endPort}}</li>
+          </div>
+        </ul>
+      </div>
+    </div>
+
+    <div class="form-group">
+      <div class="col-md-3 sm-label-right">
+        Stack
+        <help-field key="oracle.serverGroup.stack"></help-field>
+      </div>
+      <div class="col-md-7">
+        <input
+          type="text"
+          class="form-control input-sm"
+          ng-pattern="basicSettingsCtrl.stackPattern"
+          name="stack"
+          ng-model="command.stack"
+        />
+      </div>
+    </div>
+    <div class="form-group row slide-in" ng-if="basicSettings.stack.$error.pattern">
+      <div class="col-sm-9 col-sm-offset-2 error-message">
+        <span>Only dot(.) and underscore(_) special characters are allowed in the Stack field.</span>
+      </div>
+    </div>
+    <div class="form-group">
+      <div class="col-md-3 sm-label-right">
+        Detail
+        <help-field key="oracle.serverGroup.detail"></help-field>
+      </div>
+      <div class="col-md-7">
+        <input
+          type="text"
+          class="form-control input-sm"
+          ng-pattern="basicSettingsCtrl.detailPattern"
+          name="details"
+          ng-model="command.freeFormDetails"
+        />
+      </div>
+    </div>
+    <deployment-strategy-selector
+      ng-if="!command.viewState.disableStrategySelection && command.selectedProvider"
+      command="command"
+    ></deployment-strategy-selector>
+  </div>
+</div>

package/src/serverGroup/configure/wizard/capacity/capacity.html

@@ -0,0 +1,7 @@
+<div class="clearfix">
+  <div class="row">
+    <div class="col-md-12">
+      <oracle-server-group-capacity-selector command="command"></oracle-server-group-capacity-selector>
+    </div>
+  </div>
+</div>

package/src/serverGroup/configure/wizard/capacity/capacitySelector.component.html

@@ -0,0 +1,13 @@
+<div>
+  <div class="form-group">
+    <div class="col-md-12">
+      <p>Select the number of instances</p>
+    </div>
+  </div>
+  <div class="form-group">
+    <div class="col-md-3 sm-label-right">Number of Instances</div>
+    <div class="col-md-2">
+      <input type="number" class="form-control input-sm" ng-model="vm.command.capacity.desired" min="1" required />
+    </div>
+  </div>
+</div>

package/src/serverGroup/configure/wizard/capacity/capacitySelector.component.js

@@ -0,0 +1,17 @@
+'use strict';
+
+import * as angular from 'angular';
+
+export const ORACLE_SERVERGROUP_CONFIGURE_WIZARD_CAPACITY_CAPACITYSELECTOR_COMPONENT =
+  'spinnaker.oracle.serverGroup.configure.wizard.capacity.selector.component';
+export const name = ORACLE_SERVERGROUP_CONFIGURE_WIZARD_CAPACITY_CAPACITYSELECTOR_COMPONENT; // for backwards compatibility
+angular
+  .module(ORACLE_SERVERGROUP_CONFIGURE_WIZARD_CAPACITY_CAPACITYSELECTOR_COMPONENT, [])
+  .component('oracleServerGroupCapacitySelector', {
+    templateUrl: require('./capacitySelector.component.html'),
+    bindings: {
+      command: '=',
+    },
+    controllerAs: 'vm',
+    controller: angular.noop,
+  });

package/src/serverGroup/configure/wizard/cloneServerGroup.controller.js

@@ -0,0 +1,109 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import { module } from 'angular';
+
+import { FirewallLabels, ModalWizard, TaskMonitor } from '@spinnaker/core';
+
+export const ORACLE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_CONTROLLER =
+  'spinnaker.oracle.serverGroup.configure.cloneServerGroup';
+export const name = ORACLE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_CONTROLLER; // for backwards compatibility
+module(ORACLE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_CONTROLLER, [UIROUTER_ANGULARJS]).controller(
+  'oracleCloneServerGroupCtrl',
+  [
+    '$scope',
+    '$uibModalInstance',
+    '$q',
+    'application',
+    'serverGroupWriter',
+    'serverGroupCommand',
+    'oracleServerGroupConfigurationService',
+    'title',
+    function (
+      $scope,
+      $uibModalInstance,
+      $q,
+      application,
+      serverGroupWriter,
+      serverGroupCommand,
+      oracleServerGroupConfigurationService,
+      title,
+    ) {
+      $scope.title = title;
+
+      $scope.state = {
+        loaded: false,
+        requiresTemplateSelection: !!serverGroupCommand.viewState.requiresTemplateSelection,
+      };
+
+      $scope.command = serverGroupCommand;
+      $scope.application = application;
+
+      $scope.pages = {
+        basicSettings: require('./basicSettings/basicSettings.html'),
+        instanceType: require('./instanceType/instanceType.html'),
+        capacity: require('./capacity/capacity.html'),
+        loadBalancers: require('./loadBalancers/loadBalancers.html'),
+        networkSettings: require('./network/networkSettings.html'),
+        templateSelection: require('./templateSelection/templateSelection.html'),
+      };
+
+      this.templateSelectionText = {
+        copied: [
+          'account, region, subnet, cluster name (stack, details)',
+          'load balancers',
+          FirewallLabels.get('firewalls'),
+          'instance type',
+          'all fields on the Advanced Settings page',
+        ],
+        notCopied: [],
+      };
+
+      if (!$scope.command.viewState.disableStrategySelection) {
+        this.templateSelectionText.notCopied.push(
+          'the deployment strategy (if any) used to deploy the most recent server group',
+        );
+      }
+
+      $scope.taskMonitor = new TaskMonitor({
+        application: application,
+        title: 'Creating your server group',
+        modalInstance: $uibModalInstance,
+      });
+
+      function configureCommand() {
+        oracleServerGroupConfigurationService.configureCommand(application, serverGroupCommand).then(function () {
+          $scope.state.loaded = true;
+        });
+      }
+
+      this.isValid = function () {
+        return $scope.command && $scope.form.$valid && ModalWizard.isComplete();
+      };
+
+      this.showSubmitButton = function () {
+        return ModalWizard.allPagesVisited();
+      };
+
+      this.cancel = function () {
+        $uibModalInstance.dismiss();
+      };
+
+      this.submit = function () {
+        if ($scope.command.viewState.mode === 'editPipeline' || $scope.command.viewState.mode === 'createPipeline') {
+          return $uibModalInstance.close($scope.command);
+        }
+        $scope.taskMonitor.submit(function () {
+          return serverGroupWriter.cloneServerGroup($scope.command, application);
+        });
+      };
+
+      configureCommand();
+
+      this.templateSelected = () => {
+        $scope.state.requiresTemplateSelection = false;
+        configureCommand();
+      };
+    },
+  ],
+);

package/src/serverGroup/configure/wizard/instanceType/instanceType.html

@@ -0,0 +1,29 @@
+<!-- Image selection -->
+<div class="form-group" ng-if="!command.viewState.disableImageSelection">
+  <div class="col-md-3 sm-label-right">Image</div>
+  <div class="col-md-9">
+    <ui-select class="form-control input-sm" required ng-model="command.imageId">
+      <ui-select-match placeholder="Select an image">{{$select.selected.name}}</ui-select-match>
+      <ui-select-choices repeat="image.id as image in command.backingData.filtered.images">
+        <span ng-bind-html="image.name | highlight: $select.search"></span>
+      </ui-select-choices>
+    </ui-select>
+  </div>
+</div>
+
+<!-- Shape selection -->
+<div class="form-group">
+  <div class="col-md-3 sm-label-right">Shape</div>
+  <div class="col-md-9">
+    <ui-select class="form-control input-sm" required ng-model="command.shape">
+      <ui-select-match placeholder="Select compatible shape">{{$select.selected.name}}</ui-select-match>
+      <ui-select-choices
+        repeat="shape.name as shape in (!command.viewState.disableImageSelection
+                                                         ? command.backingData.filtered.shapes[command.imageId]
+                                                         : command.backingData.filtered.allShapes)"
+      >
+        <span ng-bind-html="shape.name"></span>
+      </ui-select-choices>
+    </ui-select>
+  </div>
+</div>

package/src/serverGroup/configure/wizard/loadBalancers/loadBalancers.html

@@ -0,0 +1,44 @@
+<!-- Load Balancer selection -->
+<div class="form-group">
+  <div class="col-md-3 sm-label-right">Load Balancer</div>
+  <div class="col-md-9">
+    <ui-select
+      class="form-control input-sm"
+      ng-model="command.loadBalancerId"
+      ng-change="command.backingData.loadBalancerOnChange()"
+    >
+      <ui-select-match allow-clear="true" placeholder="Select Load Balancer">{{$select.selected.name}}</ui-select-match>
+      <ui-select-choices repeat="loadBalancer.id as loadBalancer in command.backingData.filtered.loadBalancers">
+        <span ng-bind-html="loadBalancer.name | highlight: $select.search"></span>
+      </ui-select-choices>
+    </ui-select>
+  </div>
+</div>
+
+<!-- Backend set selection -->
+<div class="form-group" ng-if="command.loadBalancerId">
+  <div class="col-md-3 sm-label-right">Backend Set</div>
+  <div class="col-md-9">
+    <ui-select
+      class="form-control input-sm"
+      ng-required="command.loadBalancerId"
+      ng-model="command.backendSetName"
+      ng-change="command.backingData.backendSetOnChange()"
+    >
+      <ui-select-match placeholder="Select Backend Set">{{$select.selected.name}}</ui-select-match>
+      <ui-select-choices repeat="backendSet.name as backendSet in command.backingData.filtered.backendSets">
+        <span ng-bind-html="backendSet.name"></span>
+      </ui-select-choices>
+    </ui-select>
+  </div>
+</div>
+
+<!-- Show listeners associated with selected backend set -->
+<div class="form-group" ng-if="command.loadBalancerId && command.backendSetName">
+  <div class="col-md-3 sm-label-right">Listeners for {{command.backendSetName}}</div>
+  <div class="col-md-9">
+    <ul ng-repeat="(lisName, listener) in command.backingData.filtered.listeners">
+      <li>{{listener.protocol}}:{{listener.port}}</li>
+    </ul>
+  </div>
+</div>

package/src/serverGroup/configure/wizard/network/networkSettings.html

@@ -0,0 +1,15 @@
+<!-- SSH Key -->
+<div class="form-group">
+  <div class="col-md-3 sm-label-right">
+    SSH Key
+    <help-field key="oracle.serverGroup.sshAuthorizedKeys"></help-field>
+  </div>
+  <div class="col-md-9">
+    <textarea
+      class="form-control input-sm"
+      name="sshAuthorizedKeys"
+      placeholder="Enter the public SSH key for the default user on the instance."
+      ng-model="command.sshAuthorizedKeys"
+    ></textarea>
+  </div>
+</div>