function initializeCreateMode() {
AccountService.listAccounts('azure').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accountsLoaded = true;
ctrl.accountUpdated();
});
}
function($scope) {
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('openstack').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
$scope.targets = StageConstants.TARGET_LIST;
stage.regions = stage.regions || [];
stage.cloudProvider = 'openstack';
if (!stage.credentials && $scope.application.defaultCredentials.openstack) {
stage.credentials = $scope.application.defaultCredentials.openstack;
}
if (!stage.regions.length && $scope.application.defaultRegions.openstack) {
stage.regions.push($scope.application.defaultRegions.openstack);
}
if (!stage.target) {
stage.target = $scope.targets[0].val;
}
},
function configureCommand(application, command) {
return $q
.all({
credentialsKeyedByAccount: AccountService.getCredentialsKeyedByAccount('openstack'),
securityGroups: securityGroupReader.getAllSecurityGroups(),
loadBalancers: loadBalancerReader.loadLoadBalancers(application.name),
userDataTypes: $q.when(angular.copy(userDataTypes)),
})
.then(function(backingData) {
var loadBalancerReloader = $q.when(null);
backingData.accounts = _.keys(backingData.credentialsKeyedByAccount);
backingData.filtered = {};
command.backingData = backingData;
backingData.filtered.securityGroups = getRegionalSecurityGroups(command);
if (_.get(command, 'loadBalancers').length) {
// verify all load balancers are accounted for; otherwise, try refreshing load balancers cache
var loadBalancerNames = getLoadBalancerNames(command.backingData.loadBalancers);
if (_.intersection(loadBalancerNames, command.loadBalancers).length < command.loadBalancers.length) {
loadBalancerReloader = refreshLoadBalancers(command, true);
}
}
return $q.all([loadBalancerReloader]).then(function() {
attachEventHandlers(command);
});
});
}
ctrl.accountUpdated = function() {
AccountService.getRegionsForAccount($scope.securityGroup.credentials).then(function(regions) {
$scope.regions = regions;
$scope.securityGroup.regions = regions;
ctrl.updateName();
});
};
function($scope) {
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('azure').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
$scope.targets = StageConstants.TARGET_LIST;
stage.regions = stage.regions || [];
stage.cloudProvider = 'azure';
if (stage.isNew && $scope.application.attributes.platformHealthOnly) {
stage.interestingHealthProviderNames = []; // bypass the check for now; will change this later to ['azureService']
}
if (!stage.credentials && $scope.application.defaultCredentials.azure) {
stage.credentials = $scope.application.defaultCredentials.azure;
}
if (!stage.regions.length && $scope.application.defaultRegions.azure) {
stage.regions.push($scope.application.defaultRegions.azure);
}
if (!stage.target) {
stage.target = $scope.targets[0].val;
}
},
function($scope) {
let stage = $scope.stage;
$scope.state = {
accounts: false,
namespacesLoaded: false,
};
AccountService.listAccounts('kubernetes').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
stage.namespaces = stage.namespaces || [];
$scope.targets = StageConstants.TARGET_LIST;
stage.cloudProvider = 'kubernetes';
stage.interestingHealthProviderNames = ['KubernetesService'];
if (!stage.credentials && $scope.application.defaultCredentials.kubernetes) {
stage.credentials = $scope.application.defaultCredentials.kubernetes;
}
if (!stage.target) {
stage.target = $scope.targets[0].val;
}
},
function attemptToSetValidCredentials(application, defaultCredentials, command) {
return AccountService.listAccounts('gce').then(function(gceAccounts) {
const gceAccountNames = _.map(gceAccounts, 'name');
const firstGCEAccount = gceAccountNames[0];
const defaultCredentialsAreValid = defaultCredentials && gceAccountNames.includes(defaultCredentials);
command.credentials = defaultCredentialsAreValid ? defaultCredentials : firstGCEAccount || 'my-account-name';
});
}
this.$onInit = () => {
AccountService.getAccountDetails(this.serverGroup.account).then(details => {
// alarmServerGroup is used to trick the chart rendering into using AWS metrics
this.alarmServerGroup = {
type: 'aws',
name: this.serverGroup.name,
account: details.awsAccount,
region: this.serverGroup.region,
};
});
};
.controller('ecsDisableClusterStageCtrl', function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('ecs').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
ctrl.reset = () => {
ctrl.accountUpdated();
ctrl.resetSelectedCluster();
};
stage.regions = stage.regions || [];
stage.cloudProvider = 'ecs';
if (
stage.isNew &&
$scope.application.attributes.platformHealthOnlyShowOverride &&
$scope.application.attributes.platformHealthOnly
) {
stage.interestingHealthProviderNames = ['Ecs'];
}
if (!stage.credentials && $scope.application.defaultCredentials.ecs) {
stage.credentials = $scope.application.defaultCredentials.ecs;
}
if (!stage.regions.length && $scope.application.defaultRegions.ecs) {
stage.regions.push($scope.application.defaultRegions.ecs);
}
if (stage.remainingEnabledServerGroups === undefined) {
stage.remainingEnabledServerGroups = 1;
}
ctrl.pluralize = function(str, val) {
if (val === 1) {
return str;
}
return str + 's';
};
if (stage.preferLargerOverNewer === undefined) {
stage.preferLargerOverNewer = 'false';
}
stage.preferLargerOverNewer = stage.preferLargerOverNewer.toString();
});
.controller('awsFindAmiStageCtrl', function($scope) {
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('aws').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
$scope.selectionStrategies = [
{
label: 'Largest',
val: 'LARGEST',
description: 'When multiple server groups exist, prefer the server group with the most instances',
},
{
label: 'Newest',
val: 'NEWEST',
description: 'When multiple server groups exist, prefer the newest',
},
{
label: 'Oldest',
val: 'OLDEST',
description: 'When multiple server groups exist, prefer the oldest',
},
{
label: 'Fail',
val: 'FAIL',
description: 'When multiple server groups exist, fail',
},
];
stage.regions = stage.regions || [];
stage.cloudProvider = 'aws';
stage.selectionStrategy = stage.selectionStrategy || $scope.selectionStrategies[0].val;
if (angular.isUndefined(stage.onlyEnabled)) {
stage.onlyEnabled = true;
}
if (!stage.credentials && $scope.application.defaultCredentials.aws) {
stage.credentials = $scope.application.defaultCredentials.aws;
}
if (!stage.regions.length && $scope.application.defaultRegions.aws) {
stage.regions.push($scope.application.defaultRegions.aws);
}
$scope.$watch('stage.credentials', $scope.accountUpdated);
});
function initializeCreateMode() {
AccountService.listAccounts('dcos').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accountsLoaded = true;
var accountNames = _.map($scope.accounts, 'name');
if (accountNames.length && !accountNames.includes($scope.loadBalancer.account)) {
$scope.loadBalancer.account = accountNames[0];
}
ctrl.accountUpdated();
});
}
function configureCommand(application, command, query = '') {
let queries = command.docker.image ? [grabImageAndTag(command.docker.image.imageId)] : [];
if (query) {
queries.push(query);
}
let imagesPromise;
if (queries.length) {
imagesPromise = $q
.all(
queries.map(q =>
dcosImageReader.findImages({
provider: 'dockerRegistry',
count: 50,
q: q,
}),
),
)
.then(_.flatten);
} else {
imagesPromise = $q.when([]);
}
return $q
.all({
credentialsKeyedByAccount: AccountService.getCredentialsKeyedByAccount('dcos'),
allImages: imagesPromise,
})
.then(function(backingData) {
backingData.accounts = _.keys(backingData.credentialsKeyedByAccount);
backingData.filtered = {};
backingData.allSecrets = {};
if (application.attributes && application.attributes.secrets) {
backingData.allSecrets = JSON.parse(application.attributes.secrets);
}
if (command.viewState.contextImages) {
backingData.allImages = backingData.allImages.concat(command.viewState.contextImages);
}
command.backingData = backingData;
return $q.all().then(function() {
configureAccount(command);
attachEventHandlers(command);
});
});
}
const retrieveInstance = () => {
var extraData = {};
var instanceSummary, loadBalancers, account, region, vpcId;
app.serverGroups.data.some(function(serverGroup) {
return serverGroup.instances.some(function(possibleInstance) {
if (possibleInstance.id === instance.instanceId) {
$scope.serverGroup = serverGroup;
instanceSummary = possibleInstance;
loadBalancers = serverGroup.loadBalancers;
account = serverGroup.account;
region = serverGroup.region;
extraData.serverGroup = serverGroup.name;
return true;
}
});
});
if (instanceSummary && account && region) {
extraData.account = account;
extraData.region = region;
RecentHistoryService.addExtraDataToLatest('instances', extraData);
return $q
.all([
InstanceReader.getInstanceDetails(account, region, instance.instanceId),
AccountService.getAccountDetails(account),
])
.then(([instanceDetails, accountDetails]) => {
$scope.state.loading = false;
extractHealthMetrics(instanceSummary, instanceDetails);
$scope.instance = defaults(instanceDetails, instanceSummary);
$scope.instance.account = account;
$scope.instance.region = region;
$scope.instance.vpcId = vpcId;
$scope.instance.loadBalancers = loadBalancers;
$scope.baseIpAddress = $scope.instance.placement.containerIp || $scope.instance.placement.host;
$scope.instance.externalIpAddress = $scope.instance.placement.host;
getBastionAddressForAccount(accountDetails, region);
$scope.instance.titusUiEndpoint = this.titusUiEndpoint;
if (overrides.instanceDetailsLoaded) {
overrides.instanceDetailsLoaded();
}
}, autoClose);
}
if (!instanceSummary) {
$scope.instanceIdNotFound = instance.instanceId;
$scope.state.loading = false;
}
return $q.when(null);
};
.controller('gceCreateSecurityGroupCtrl', function(
$scope,
$uibModalInstance,
$state,
$controller,
application,
securityGroup,
) {
$scope.pages = {
location: require('./createSecurityGroupProperties.html'),
targets: require('./createSecurityGroupTargets.html'),
sourceFilters: require('./createSecurityGroupSourceFilters.html'),
ingress: require('./createSecurityGroupIngress.html'),
};
var ctrl = this;
securityGroup.backingData = {};
securityGroup.network = 'default';
securityGroup.sourceRanges = [];
securityGroup.sourceTags = [];
securityGroup.ipIngress = [];
angular.extend(
this,
$controller('gceConfigSecurityGroupMixin', {
$scope: $scope,
$uibModalInstance: $uibModalInstance,
application: application,
securityGroup: securityGroup,
mode: 'create',
}),
);
AccountService.listAccounts('gce').then(function(accounts) {
$scope.accounts = accounts;
ctrl.accountUpdated();
});
this.getSecurityGroupRefreshTime = function() {
return InfrastructureCaches.get('securityGroups').getStats().ageMax;
};
ctrl.upsert = function() {
ctrl.mixinUpsert('Create');
};
ctrl.initializeSecurityGroups();
});
let 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;
}
},
);
}
};
function initializeCreateMode() {
return $q
.all({
accounts: AccountService.listAccounts('openstack'),
})
.then(function(backingData) {
$scope.accounts = backingData.accounts;
var accountNames = _.map($scope.accounts, 'name');
if (accountNames.length && !accountNames.includes($scope.securityGroup.account)) {
$scope.securityGroup.account = accountNames[0];
}
$scope.loadBalancers = getLoadBalancerNames(backingData.loadBalancers);
ctrl.accountUpdated();
});
}
.controller('ecsEnableAsgStageCtrl', function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('ecs').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
ctrl.reset = () => {
ctrl.accountUpdated();
ctrl.resetSelectedCluster();
};
$scope.targets = StageConstants.TARGET_LIST;
stage.regions = stage.regions || [];
stage.cloudProvider = 'ecs';
if (
stage.isNew &&
$scope.application.attributes.platformHealthOnlyShowOverride &&
$scope.application.attributes.platformHealthOnly
) {
stage.interestingHealthProviderNames = ['Ecs'];
}
if (!stage.credentials && $scope.application.defaultCredentials.ecs) {
stage.credentials = $scope.application.defaultCredentials.ecs;
}
if (!stage.regions.length && $scope.application.defaultRegions.ecs) {
stage.regions.push($scope.application.defaultRegions.ecs);
}
if (!stage.target) {
stage.target = $scope.targets[0].val;
}
$scope.$watch('stage.credentials', $scope.accountUpdated);
});
.controller('gceScaleDownClusterStageCtrl', function($scope) {
var ctrl = this;
let 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.remainingFullSizeServerGroups === undefined) {
stage.remainingFullSizeServerGroups = 1;
}
if (stage.allowScaleDownActive === undefined) {
stage.allowScaleDownActive = false;
}
ctrl.pluralize = function(str, val) {
if (val === 1) {
return str;
}
return str + 's';
};
if (stage.preferLargerOverNewer === undefined) {
stage.preferLargerOverNewer = 'false';
}
stage.preferLargerOverNewer = stage.preferLargerOverNewer.toString();
});
function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('aws').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
stage.regions = stage.regions || [];
stage.cloudProvider = 'aws';
if (!stage.credentials && $scope.application.defaultCredentials.aws) {
stage.credentials = $scope.application.defaultCredentials.aws;
}
if (!stage.regions.length && $scope.application.defaultRegions.aws) {
stage.regions.push($scope.application.defaultRegions.aws);
}
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();
},
.controller('azureEnableAsgStageCtrl', function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('azure').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
ctrl.reset = () => {
ctrl.accountUpdated();
ctrl.resetSelectedCluster();
};
$scope.targets = StageConstants.TARGET_LIST;
stage.regions = stage.regions || [];
stage.cloudProvider = 'azure';
if (stage.isNew) {
// bypass the health check for now; will change this later to ['azureService'] and we will also add back the check for $scope.application.attributes.platformHealthOnly
stage.interestingHealthProviderNames = [];
}
if (!stage.credentials && $scope.application.defaultCredentials.azure) {
stage.credentials = $scope.application.defaultCredentials.azure;
}
if (!stage.regions.length && $scope.application.defaultRegions.azure) {
stage.regions.push($scope.application.defaultRegions.azure);
}
if (!stage.target) {
stage.target = $scope.targets[0].val;
}
$scope.$watch('stage.credentials', $scope.accountUpdated);
});
function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.state = {
accounts: false,
namespacesLoaded: false,
};
AccountService.listAccounts('kubernetes').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
stage.namespaces = stage.namespaces || [];
stage.cloudProvider = 'kubernetes';
if (!stage.credentials && $scope.application.defaultCredentials.kubernetes) {
stage.credentials = $scope.application.defaultCredentials.kubernetes;
}
if (stage.remainingFullSizeServerGroups === undefined) {
stage.remainingFullSizeServerGroups = 1;
}
if (stage.allowScaleDownActive === undefined) {
stage.allowScaleDownActive = false;
}
ctrl.pluralize = function(str, val) {
if (val === 1) {
return str;
}
return str + 's';
};
if (stage.preferLargerOverNewer === undefined) {
stage.preferLargerOverNewer = 'false';
}
stage.preferLargerOverNewer = stage.preferLargerOverNewer.toString();
},
function attemptToSetValidAccount(defaultAccount, defaultDcosCluster, loadBalancer) {
return AccountService.getCredentialsKeyedByAccount('dcos').then(function(dcosAccountsByName) {
var dcosAccountNames = _.keys(dcosAccountsByName);
var firstDcosAccount = null;
if (dcosAccountNames.length) {
firstDcosAccount = dcosAccountNames[0];
}
var defaultAccountIsValid = defaultAccount && dcosAccountNames.includes(defaultAccount);
loadBalancer.account = defaultAccountIsValid
? defaultAccount
: firstDcosAccount
? firstDcosAccount
: 'my-dcos-account';
attemptToSetValidDcosCluster(dcosAccountsByName, defaultDcosCluster, loadBalancer);
});
}
function($scope) {
const stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('gce').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
$scope.targets = StageConstants.TARGET_LIST;
stage.regions = stage.regions || [];
stage.cloudProvider = 'gce';
if (
stage.isNew &&
$scope.application.attributes.platformHealthOnlyShowOverride &&
$scope.application.attributes.platformHealthOnly
) {
stage.interestingHealthProviderNames = ['Google'];
}
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.target) {
stage.target = $scope.targets[0].val;
}
$scope.$watch('stage.credentials', $scope.accountUpdated);
},
.controller('awsRollbackClusterStageCtrl', function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.state = {
accounts: false,
regionsLoaded: false,
};
AccountService.listAccounts('aws').then(function(accounts) {
$scope.accounts = accounts;
$scope.state.accounts = true;
});
ctrl.reset = () => {
ctrl.accountUpdated();
ctrl.resetSelectedCluster();
};
stage.regions = stage.regions || [];
stage.cloudProvider = 'aws';
stage.targetHealthyRollbackPercentage = stage.targetHealthyRollbackPercentage || 100;
if (
stage.isNew &&
$scope.application.attributes.platformHealthOnlyShowOverride &&
$scope.application.attributes.platformHealthOnly
) {
stage.interestingHealthProviderNames = ['Amazon'];
}
if (!stage.credentials && $scope.application.defaultCredentials.aws) {
stage.credentials = $scope.application.defaultCredentials.aws;
}
if (!stage.regions.length && $scope.application.defaultRegions.aws) {
stage.regions.push($scope.application.defaultRegions.aws);
}
});
function attemptToSetValidAccount(application, defaultAccount, defaultDcosCluster, command) {
return AccountService.getCredentialsKeyedByAccount('dcos').then(function(dcosAccountsByName) {
var dcosAccountNames = _.keys(dcosAccountsByName);
var firstDcosAccount = null;
if (application.accounts.length) {
firstDcosAccount = _.find(application.accounts, function(applicationAccount) {
return dcosAccountNames.includes(applicationAccount);
});
} else if (dcosAccountNames.length) {
firstDcosAccount = dcosAccountNames[0];
}
var defaultAccountIsValid = defaultAccount && dcosAccountNames.includes(defaultAccount);
command.account = defaultAccountIsValid
? defaultAccount
: firstDcosAccount
? firstDcosAccount
: 'my-dcos-account';
attemptToSetValidDcosCluster(dcosAccountsByName, defaultDcosCluster, command);
});
}
.controller('dcosResizeAsgStageCtrl', function($scope) {
var ctrl = this;
let stage = $scope.stage;
$scope.viewState = {
accountsLoaded: false,
regionsLoaded: false,
};
AccountService.listAccounts('dcos').then(function(accounts) {
$scope.accounts = accounts;
$scope.viewState.accountsLoaded = true;
});
$scope.resizeTargets = StageConstants.TARGET_LIST;
$scope.scaleActions = [
{
label: 'Scale Up',
val: 'scale_up',
},
{
label: 'Scale Down',
val: 'scale_down',
},
{
label: 'Scale to Cluster Size',
val: 'scale_to_cluster',
},
{
label: 'Scale to Exact Size',
val: 'scale_exact',
},
];
$scope.resizeTypes = [
{
label: 'Percentage',
val: 'pct',
},
{
label: 'Incremental',
val: 'incr',
},
];
stage.capacity = stage.capacity || {};
stage.regions = stage.regions || [];
stage.target = stage.target || $scope.resizeTargets[0].val;
stage.action = stage.action || $scope.scaleActions[0].val;
stage.resizeType = stage.resizeType || $scope.resizeTypes[0].val;
if (!stage.action && stage.resizeType === 'exact') {
stage.action = 'scale_exact';
}
stage.cloudProvider = 'dcos';
if (!stage.credentials && $scope.application.defaultCredentials.dcos) {
stage.credentials = $scope.application.defaultCredentials.dcos;
}
if (!stage.regions.length && $scope.application.defaultRegions.dcos) {
stage.regions.push($scope.application.defaultRegions.dcos);
}
ctrl.updateResizeType = function() {
if (stage.action === 'scale_exact') {
stage.resizeType = 'exact';
delete stage.scalePct;
delete stage.scaleNum;
} else {
stage.capacity = {};
if (stage.resizeType === 'pct') {
delete stage.scaleNum;
} else {
stage.resizeType = 'incr';
delete stage.scalePct;
stage.scaleNum = stage.scaleNum || 0;
}
}
};
});
function buildNewServerGroupCommand(application, defaults) {
defaults = defaults || {};
var credentialsLoader = AccountService.getCredentialsKeyedByAccount('ecs');
var defaultCredentials = defaults.account || application.defaultCredentials.ecs;
var defaultRegion = defaults.region || application.defaultRegions.ecs;
var preferredZonesLoader = AccountService.getAvailabilityZonesForAccountAndRegion(
'ecs',
defaultCredentials,
defaultRegion,
);
return $q
.all({
preferredZones: preferredZonesLoader,
credentialsKeyedByAccount: credentialsLoader,
})
.then(function(asyncData) {
var availabilityZones = asyncData.preferredZones;
var defaultIamRole = 'None (No IAM role)';
defaultIamRole = defaultIamRole.replace('{{application}}', application.name);
var command = {
application: application.name,
credentials: defaultCredentials,
region: defaultRegion,
strategy: '',
capacity: {
min: 1,
max: 1,
desired: 1,
},
healthCheckType: 'EC2',
selectedProvider: 'ecs',
iamRole: defaultIamRole,
availabilityZones: availabilityZones,
autoscalingPolicies: [],
subnetType: '',
securityGroups: [],
healthgraceperiod: '',
placementStrategyName: '',
placementStrategySequence: [],
ecsClusterName: '',
targetGroup: '',
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 buildServerGroupCommandFromExisting(application, serverGroup, mode = 'clone') {
var preferredZonesLoader = AccountService.getPreferredZonesByAccount('ecs');
var serverGroupName = NameUtils.parseServerGroupName(serverGroup.asg.autoScalingGroupName);
var asyncLoader = $q.all({
preferredZones: preferredZonesLoader,
});
return asyncLoader.then(function(asyncData) {
var zones = serverGroup.asg.availabilityZones.sort();
var usePreferredZones = false;
var preferredZonesForAccount = asyncData.preferredZones[serverGroup.account];
if (preferredZonesForAccount) {
var preferredZones = preferredZonesForAccount[serverGroup.region].sort();
usePreferredZones = zones.join(',') === preferredZones.join(',');
}
// These processes should never be copied over, as the affect launching instances and enabling traffic
let enabledProcesses = ['Launch', 'Terminate', 'AddToLoadBalancer'];
var command = {
application: application.name,
strategy: '',
stack: serverGroupName.stack,
freeFormDetails: serverGroupName.freeFormDetails,
credentials: serverGroup.account,
healthCheckType: serverGroup.asg.healthCheckType,
loadBalancers: serverGroup.asg.loadBalancerNames,
region: serverGroup.region,
useSourceCapacity: false,
capacity: {
min: serverGroup.asg.minSize,
max: serverGroup.asg.maxSize,
desired: serverGroup.asg.desiredCapacity,
},
availabilityZones: zones,
selectedProvider: CLOUD_PROVIDER,
source: {
account: serverGroup.account,
region: serverGroup.region,
asgName: serverGroup.asg.autoScalingGroupName,
},
suspendedProcesses: (serverGroup.asg.suspendedProcesses || [])
.map(process => process.processName)
.filter(name => !enabledProcesses.includes(name)),
targetGroup: serverGroup.targetGroup,
viewState: {
instanceProfile: asyncData.instanceProfile,
useAllImageSelection: false,
useSimpleCapacity: serverGroup.asg.minSize === serverGroup.asg.maxSize,
usePreferredZones: usePreferredZones,
mode: mode,
isNew: false,
dirty: {},
},
};
if (mode === 'clone' || mode === 'editPipeline') {
command.useSourceCapacity = true;
}
if (mode === 'editPipeline') {
command.strategy = 'redblack';
command.suspendedProcesses = [];
}
if (serverGroup.launchConfig) {
angular.extend(command, {
iamRole: serverGroup.launchConfig.iamInstanceProfile,
});
if (serverGroup.launchConfig.userData) {
command.base64UserData = serverGroup.launchConfig.userData;
}
command.viewState.imageId = serverGroup.launchConfig.imageId;
}
return command;
});
}
function buildNewServerGroupCommand(application, defaults) {
defaults = defaults || {};
var credentialsLoader = AccountService.getCredentialsKeyedByAccount('aws');
var defaultCredentials =
defaults.account || application.defaultCredentials.aws || AWSProviderSettings.defaults.account;
var defaultRegion = defaults.region || application.defaultRegions.aws || AWSProviderSettings.defaults.region;
var defaultSubnet = defaults.subnet || AWSProviderSettings.defaults.subnetType || '';
var preferredZonesLoader = AccountService.getAvailabilityZonesForAccountAndRegion(
'aws',
defaultCredentials,
defaultRegion,
);
return $q
.all({
preferredZones: preferredZonesLoader,
credentialsKeyedByAccount: credentialsLoader,
})
.then(function(asyncData) {
var availabilityZones = asyncData.preferredZones;
var credentials = asyncData.credentialsKeyedByAccount[defaultCredentials];
var keyPair = credentials ? credentials.defaultKeyPair : null;
var applicationAwsSettings = _.get(application, 'attributes.providerSettings.aws', {});
var defaultIamRole = AWSProviderSettings.defaults.iamRole || 'BaseIAMRole';
defaultIamRole = defaultIamRole.replace('{{application}}', application.name);
var useAmiBlockDeviceMappings = applicationAwsSettings.useAmiBlockDeviceMappings || false;
var command = {
application: application.name,
credentials: defaultCredentials,
region: defaultRegion,
strategy: '',
capacity: {
min: 1,
max: 1,
desired: 1,
},
targetHealthyDeployPercentage: 100,
cooldown: 10,
enabledMetrics: [],
healthCheckType: 'EC2',
healthCheckGracePeriod: 600,
instanceMonitoring: false,
ebsOptimized: false,
selectedProvider: 'aws',
iamRole: defaultIamRole,
terminationPolicies: ['Default'],
vpcId: null,
subnetType: defaultSubnet,
availabilityZones: availabilityZones,
keyPair: keyPair,
suspendedProcesses: [],
securityGroups: [],
stack: '',
freeFormDetails: '',
spotPrice: '',
tags: {},
useAmiBlockDeviceMappings: useAmiBlockDeviceMappings,
copySourceCustomBlockDeviceMappings: false, // default to using block device mappings from current instance type
viewState: {
instanceProfile: 'custom',
useAllImageSelection: false,
useSimpleCapacity: true,
usePreferredZones: true,
mode: defaults.mode || 'create',
disableStrategySelection: true,
dirty: {},
submitButtonLabel: getSubmitButtonLabel(defaults.mode || 'create'),
},
};
if (
application.attributes &&
application.attributes.platformHealthOnlyShowOverride &&
application.attributes.platformHealthOnly
) {
command.interestingHealthProviderNames = ['Amazon'];
}
return command;
});
}
function buildServerGroupCommandFromExisting(application, serverGroup, mode = 'clone') {
var preferredZonesLoader = AccountService.getPreferredZonesByAccount('aws');
var subnetsLoader = SubnetReader.listSubnets();
var serverGroupName = NameUtils.parseServerGroupName(serverGroup.asg.autoScalingGroupName);
var instanceType = serverGroup.launchConfig ? serverGroup.launchConfig.instanceType : null;
var instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType('aws', instanceType);
var asyncLoader = $q.all({
preferredZones: preferredZonesLoader,
subnets: subnetsLoader,
instanceProfile: instanceTypeCategoryLoader,
});
return asyncLoader.then(function(asyncData) {
var zones = serverGroup.asg.availabilityZones.sort();
var usePreferredZones = false;
var preferredZonesForAccount = asyncData.preferredZones[serverGroup.account];
if (preferredZonesForAccount) {
var preferredZones = preferredZonesForAccount[serverGroup.region].sort();
usePreferredZones = zones.join(',') === preferredZones.join(',');
}
// These processes should never be copied over, as the affect launching instances and enabling traffic
let enabledProcesses = ['Launch', 'Terminate', 'AddToLoadBalancer'];
var applicationAwsSettings = _.get(application, 'attributes.providerSettings.aws', {});
var useAmiBlockDeviceMappings = applicationAwsSettings.useAmiBlockDeviceMappings || false;
const existingTags = {};
// These tags are applied by Clouddriver (if configured to do so), regardless of what the user might enter
// Might be worth feature flagging this if it turns out other folks are hard-coding these values
const reservedTags = ['spinnaker:application', 'spinnaker:stack', 'spinnaker:details'];
if (serverGroup.asg.tags) {
serverGroup.asg.tags
.filter(t => !reservedTags.includes(t.key))
.forEach(tag => {
existingTags[tag.key] = tag.value;
});
}
var command = {
application: application.name,
strategy: '',
stack: serverGroupName.stack,
freeFormDetails: serverGroupName.freeFormDetails,
credentials: serverGroup.account,
cooldown: serverGroup.asg.defaultCooldown,
enabledMetrics: _.get(serverGroup, 'asg.enabledMetrics', []).map(m => m.metric),
healthCheckGracePeriod: serverGroup.asg.healthCheckGracePeriod,
healthCheckType: serverGroup.asg.healthCheckType,
terminationPolicies: serverGroup.asg.terminationPolicies,
loadBalancers: serverGroup.asg.loadBalancerNames,
region: serverGroup.region,
useSourceCapacity: false,
capacity: {
min: serverGroup.asg.minSize,
max: serverGroup.asg.maxSize,
desired: serverGroup.asg.desiredCapacity,
},
targetHealthyDeployPercentage: 100,
availabilityZones: zones,
selectedProvider: 'aws',
source: {
account: serverGroup.account,
region: serverGroup.region,
asgName: serverGroup.asg.autoScalingGroupName,
},
suspendedProcesses: (serverGroup.asg.suspendedProcesses || [])
.map(process => process.processName)
.filter(name => !enabledProcesses.includes(name)),
tags: Object.assign({}, serverGroup.tags, existingTags),
targetGroups: serverGroup.targetGroups,
useAmiBlockDeviceMappings: useAmiBlockDeviceMappings,
copySourceCustomBlockDeviceMappings: mode === 'clone', // default to using block device mappings if not cloning
viewState: {
instanceProfile: asyncData.instanceProfile,
useAllImageSelection: false,
useSimpleCapacity: serverGroup.asg.minSize === serverGroup.asg.maxSize,
usePreferredZones: usePreferredZones,
mode: mode,
submitButtonLabel: getSubmitButtonLabel(mode),
isNew: false,
dirty: {},
},
};
if (
application.attributes &&
application.attributes.platformHealthOnlyShowOverride &&
application.attributes.platformHealthOnly
) {
command.interestingHealthProviderNames = ['Amazon'];
}
if (mode === 'editPipeline') {
command.useSourceCapacity = true;
command.viewState.useSimpleCapacity = false;
command.strategy = 'redblack';
command.suspendedProcesses = [];
}
var vpcZoneIdentifier = serverGroup.asg.vpczoneIdentifier;
if (vpcZoneIdentifier !== '') {
var subnetId = vpcZoneIdentifier.split(',')[0];
var subnet = _.chain(asyncData.subnets)
.find({ id: subnetId })
.value();
command.subnetType = subnet.purpose;
command.vpcId = subnet.vpcId;
} else {
command.subnetType = '';
command.vpcId = null;
}
if (serverGroup.launchConfig) {
angular.extend(command, {
instanceType: serverGroup.launchConfig.instanceType,
iamRole: serverGroup.launchConfig.iamInstanceProfile,
keyPair: serverGroup.launchConfig.keyName,
associatePublicIpAddress: serverGroup.launchConfig.associatePublicIpAddress,
ramdiskId: serverGroup.launchConfig.ramdiskId,
instanceMonitoring: serverGroup.launchConfig.instanceMonitoring.enabled,
ebsOptimized: serverGroup.launchConfig.ebsOptimized,
spotPrice: serverGroup.launchConfig.spotPrice,
});
if (serverGroup.launchConfig.userData) {
command.base64UserData = serverGroup.launchConfig.userData;
}
command.viewState.imageId = serverGroup.launchConfig.imageId;
}
if (mode === 'clone' && serverGroup.image && serverGroup.image.name) {
command.amiName = serverGroup.image.name;
}
if (serverGroup.launchConfig && serverGroup.launchConfig.securityGroups.length) {
command.securityGroups = serverGroup.launchConfig.securityGroups;
}
return command;
});
}