599 lines
29 KiB
C++
599 lines
29 KiB
C++
/*
|
|
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <alibabacloud/ecs/model/CreateAutoProvisioningGroupRequest.h>
|
|
|
|
using AlibabaCloud::Ecs::Model::CreateAutoProvisioningGroupRequest;
|
|
|
|
CreateAutoProvisioningGroupRequest::CreateAutoProvisioningGroupRequest()
|
|
: RpcServiceRequest("ecs", "2014-05-26", "CreateAutoProvisioningGroup") {
|
|
setMethod(HttpRequest::Method::Post);
|
|
}
|
|
|
|
CreateAutoProvisioningGroupRequest::~CreateAutoProvisioningGroupRequest() {}
|
|
|
|
std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationDataDisk> CreateAutoProvisioningGroupRequest::getLaunchConfigurationDataDisk() const {
|
|
return launchConfigurationDataDisk_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationDataDisk(const std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationDataDisk> &launchConfigurationDataDisk) {
|
|
launchConfigurationDataDisk_ = launchConfigurationDataDisk;
|
|
for(int dep1 = 0; dep1 != launchConfigurationDataDisk.size(); dep1++) {
|
|
auto launchConfigurationDataDiskObj = launchConfigurationDataDisk.at(dep1);
|
|
std::string launchConfigurationDataDiskObjStr = std::string("LaunchConfiguration.DataDisk") + "." + std::to_string(dep1 + 1);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".PerformanceLevel", launchConfigurationDataDiskObj.performanceLevel);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".KmsKeyId", launchConfigurationDataDiskObj.kmsKeyId);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".Description", launchConfigurationDataDiskObj.description);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".SnapshotId", launchConfigurationDataDiskObj.snapshotId);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".Size", std::to_string(launchConfigurationDataDiskObj.size));
|
|
setParameter(launchConfigurationDataDiskObjStr + ".Device", launchConfigurationDataDiskObj.device);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".DiskName", launchConfigurationDataDiskObj.diskName);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".Category", launchConfigurationDataDiskObj.category);
|
|
setParameter(launchConfigurationDataDiskObjStr + ".DeleteWithInstance", launchConfigurationDataDiskObj.deleteWithInstance ? "true" : "false");
|
|
setParameter(launchConfigurationDataDiskObjStr + ".Encrypted", launchConfigurationDataDiskObj.encrypted ? "true" : "false");
|
|
}
|
|
}
|
|
|
|
long CreateAutoProvisioningGroupRequest::getResourceOwnerId() const {
|
|
return resourceOwnerId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setResourceOwnerId(long resourceOwnerId) {
|
|
resourceOwnerId_ = resourceOwnerId;
|
|
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskCategory() const {
|
|
return launchConfigurationSystemDiskCategory_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskCategory(const std::string &launchConfigurationSystemDiskCategory) {
|
|
launchConfigurationSystemDiskCategory_ = launchConfigurationSystemDiskCategory;
|
|
setParameter(std::string("LaunchConfiguration.SystemDiskCategory"), launchConfigurationSystemDiskCategory);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getAutoProvisioningGroupType() const {
|
|
return autoProvisioningGroupType_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setAutoProvisioningGroupType(const std::string &autoProvisioningGroupType) {
|
|
autoProvisioningGroupType_ = autoProvisioningGroupType;
|
|
setParameter(std::string("AutoProvisioningGroupType"), autoProvisioningGroupType);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskPerformanceLevel() const {
|
|
return launchConfigurationSystemDiskPerformanceLevel_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskPerformanceLevel(const std::string &launchConfigurationSystemDiskPerformanceLevel) {
|
|
launchConfigurationSystemDiskPerformanceLevel_ = launchConfigurationSystemDiskPerformanceLevel;
|
|
setParameter(std::string("LaunchConfiguration.SystemDiskPerformanceLevel"), launchConfigurationSystemDiskPerformanceLevel);
|
|
}
|
|
|
|
std::vector<std::string> CreateAutoProvisioningGroupRequest::getLaunchConfigurationHostNames() const {
|
|
return launchConfigurationHostNames_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationHostNames(const std::vector<std::string> &launchConfigurationHostNames) {
|
|
launchConfigurationHostNames_ = launchConfigurationHostNames;
|
|
}
|
|
|
|
std::vector<std::string> CreateAutoProvisioningGroupRequest::getLaunchConfigurationSecurityGroupIds() const {
|
|
return launchConfigurationSecurityGroupIds_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSecurityGroupIds(const std::vector<std::string> &launchConfigurationSecurityGroupIds) {
|
|
launchConfigurationSecurityGroupIds_ = launchConfigurationSecurityGroupIds;
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getResourceGroupId() const {
|
|
return resourceGroupId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setResourceGroupId(const std::string &resourceGroupId) {
|
|
resourceGroupId_ = resourceGroupId;
|
|
setParameter(std::string("ResourceGroupId"), resourceGroupId);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationImageId() const {
|
|
return launchConfigurationImageId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationImageId(const std::string &launchConfigurationImageId) {
|
|
launchConfigurationImageId_ = launchConfigurationImageId;
|
|
setParameter(std::string("LaunchConfiguration.ImageId"), launchConfigurationImageId);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationResourceGroupId() const {
|
|
return launchConfigurationResourceGroupId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationResourceGroupId(const std::string &launchConfigurationResourceGroupId) {
|
|
launchConfigurationResourceGroupId_ = launchConfigurationResourceGroupId;
|
|
setParameter(std::string("LaunchConfiguration.ResourceGroupId"), launchConfigurationResourceGroupId);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationPassword() const {
|
|
return launchConfigurationPassword_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationPassword(const std::string &launchConfigurationPassword) {
|
|
launchConfigurationPassword_ = launchConfigurationPassword;
|
|
setParameter(std::string("LaunchConfiguration.Password"), launchConfigurationPassword);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getPayAsYouGoAllocationStrategy() const {
|
|
return payAsYouGoAllocationStrategy_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setPayAsYouGoAllocationStrategy(const std::string &payAsYouGoAllocationStrategy) {
|
|
payAsYouGoAllocationStrategy_ = payAsYouGoAllocationStrategy;
|
|
setParameter(std::string("PayAsYouGoAllocationStrategy"), payAsYouGoAllocationStrategy);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getDefaultTargetCapacityType() const {
|
|
return defaultTargetCapacityType_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setDefaultTargetCapacityType(const std::string &defaultTargetCapacityType) {
|
|
defaultTargetCapacityType_ = defaultTargetCapacityType;
|
|
setParameter(std::string("DefaultTargetCapacityType"), defaultTargetCapacityType);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationKeyPairName() const {
|
|
return launchConfigurationKeyPairName_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationKeyPairName(const std::string &launchConfigurationKeyPairName) {
|
|
launchConfigurationKeyPairName_ = launchConfigurationKeyPairName;
|
|
setParameter(std::string("LaunchConfiguration.KeyPairName"), launchConfigurationKeyPairName);
|
|
}
|
|
|
|
std::vector<CreateAutoProvisioningGroupRequest::SystemDiskConfig> CreateAutoProvisioningGroupRequest::getSystemDiskConfig() const {
|
|
return systemDiskConfig_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setSystemDiskConfig(const std::vector<CreateAutoProvisioningGroupRequest::SystemDiskConfig> &systemDiskConfig) {
|
|
systemDiskConfig_ = systemDiskConfig;
|
|
for(int dep1 = 0; dep1 != systemDiskConfig.size(); dep1++) {
|
|
auto systemDiskConfigObj = systemDiskConfig.at(dep1);
|
|
std::string systemDiskConfigObjStr = std::string("SystemDiskConfig") + "." + std::to_string(dep1 + 1);
|
|
setParameter(systemDiskConfigObjStr + ".DiskCategory", systemDiskConfigObj.diskCategory);
|
|
}
|
|
}
|
|
|
|
std::vector<CreateAutoProvisioningGroupRequest::DataDiskConfig> CreateAutoProvisioningGroupRequest::getDataDiskConfig() const {
|
|
return dataDiskConfig_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setDataDiskConfig(const std::vector<CreateAutoProvisioningGroupRequest::DataDiskConfig> &dataDiskConfig) {
|
|
dataDiskConfig_ = dataDiskConfig;
|
|
for(int dep1 = 0; dep1 != dataDiskConfig.size(); dep1++) {
|
|
auto dataDiskConfigObj = dataDiskConfig.at(dep1);
|
|
std::string dataDiskConfigObjStr = std::string("DataDiskConfig") + "." + std::to_string(dep1 + 1);
|
|
setParameter(dataDiskConfigObjStr + ".DiskCategory", dataDiskConfigObj.diskCategory);
|
|
}
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getValidUntil() const {
|
|
return validUntil_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setValidUntil(const std::string &validUntil) {
|
|
validUntil_ = validUntil;
|
|
setParameter(std::string("ValidUntil"), validUntil);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchTemplateId() const {
|
|
return launchTemplateId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchTemplateId(const std::string &launchTemplateId) {
|
|
launchTemplateId_ = launchTemplateId;
|
|
setParameter(std::string("LaunchTemplateId"), launchTemplateId);
|
|
}
|
|
|
|
long CreateAutoProvisioningGroupRequest::getOwnerId() const {
|
|
return ownerId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setOwnerId(long ownerId) {
|
|
ownerId_ = ownerId;
|
|
setParameter(std::string("OwnerId"), std::to_string(ownerId));
|
|
}
|
|
|
|
int CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskSize() const {
|
|
return launchConfigurationSystemDiskSize_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskSize(int launchConfigurationSystemDiskSize) {
|
|
launchConfigurationSystemDiskSize_ = launchConfigurationSystemDiskSize;
|
|
setParameter(std::string("LaunchConfiguration.SystemDiskSize"), std::to_string(launchConfigurationSystemDiskSize));
|
|
}
|
|
|
|
int CreateAutoProvisioningGroupRequest::getLaunchConfigurationInternetMaxBandwidthOut() const {
|
|
return launchConfigurationInternetMaxBandwidthOut_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInternetMaxBandwidthOut(int launchConfigurationInternetMaxBandwidthOut) {
|
|
launchConfigurationInternetMaxBandwidthOut_ = launchConfigurationInternetMaxBandwidthOut;
|
|
setParameter(std::string("LaunchConfiguration.InternetMaxBandwidthOut"), std::to_string(launchConfigurationInternetMaxBandwidthOut));
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationHostName() const {
|
|
return launchConfigurationHostName_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationHostName(const std::string &launchConfigurationHostName) {
|
|
launchConfigurationHostName_ = launchConfigurationHostName;
|
|
setParameter(std::string("LaunchConfiguration.HostName"), launchConfigurationHostName);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getMinTargetCapacity() const {
|
|
return minTargetCapacity_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setMinTargetCapacity(const std::string &minTargetCapacity) {
|
|
minTargetCapacity_ = minTargetCapacity;
|
|
setParameter(std::string("MinTargetCapacity"), minTargetCapacity);
|
|
}
|
|
|
|
float CreateAutoProvisioningGroupRequest::getMaxSpotPrice() const {
|
|
return maxSpotPrice_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setMaxSpotPrice(float maxSpotPrice) {
|
|
maxSpotPrice_ = maxSpotPrice;
|
|
setParameter(std::string("MaxSpotPrice"), std::to_string(maxSpotPrice));
|
|
}
|
|
|
|
std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationArn> CreateAutoProvisioningGroupRequest::getLaunchConfigurationArn() const {
|
|
return launchConfigurationArn_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationArn(const std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationArn> &launchConfigurationArn) {
|
|
launchConfigurationArn_ = launchConfigurationArn;
|
|
for(int dep1 = 0; dep1 != launchConfigurationArn.size(); dep1++) {
|
|
auto launchConfigurationArnObj = launchConfigurationArn.at(dep1);
|
|
std::string launchConfigurationArnObjStr = std::string("LaunchConfiguration.Arn") + "." + std::to_string(dep1 + 1);
|
|
setParameter(launchConfigurationArnObjStr + ".Rolearn", launchConfigurationArnObj.rolearn);
|
|
setParameter(launchConfigurationArnObjStr + ".RoleType", launchConfigurationArnObj.roleType);
|
|
setParameter(launchConfigurationArnObjStr + ".AssumeRoleFor", std::to_string(launchConfigurationArnObj.assumeRoleFor));
|
|
}
|
|
}
|
|
|
|
bool CreateAutoProvisioningGroupRequest::getLaunchConfigurationPasswordInherit() const {
|
|
return launchConfigurationPasswordInherit_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationPasswordInherit(bool launchConfigurationPasswordInherit) {
|
|
launchConfigurationPasswordInherit_ = launchConfigurationPasswordInherit;
|
|
setParameter(std::string("LaunchConfiguration.PasswordInherit"), launchConfigurationPasswordInherit ? "true" : "false");
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getClientToken() const {
|
|
return clientToken_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setClientToken(const std::string &clientToken) {
|
|
clientToken_ = clientToken;
|
|
setParameter(std::string("ClientToken"), clientToken);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSecurityGroupId() const {
|
|
return launchConfigurationSecurityGroupId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSecurityGroupId(const std::string &launchConfigurationSecurityGroupId) {
|
|
launchConfigurationSecurityGroupId_ = launchConfigurationSecurityGroupId;
|
|
setParameter(std::string("LaunchConfiguration.SecurityGroupId"), launchConfigurationSecurityGroupId);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getDescription() const {
|
|
return description_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setDescription(const std::string &description) {
|
|
description_ = description;
|
|
setParameter(std::string("Description"), description);
|
|
}
|
|
|
|
bool CreateAutoProvisioningGroupRequest::getTerminateInstancesWithExpiration() const {
|
|
return terminateInstancesWithExpiration_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setTerminateInstancesWithExpiration(bool terminateInstancesWithExpiration) {
|
|
terminateInstancesWithExpiration_ = terminateInstancesWithExpiration;
|
|
setParameter(std::string("TerminateInstancesWithExpiration"), terminateInstancesWithExpiration ? "true" : "false");
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationUserData() const {
|
|
return launchConfigurationUserData_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationUserData(const std::string &launchConfigurationUserData) {
|
|
launchConfigurationUserData_ = launchConfigurationUserData;
|
|
setParameter(std::string("LaunchConfiguration.UserData"), launchConfigurationUserData);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationCreditSpecification() const {
|
|
return launchConfigurationCreditSpecification_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationCreditSpecification(const std::string &launchConfigurationCreditSpecification) {
|
|
launchConfigurationCreditSpecification_ = launchConfigurationCreditSpecification;
|
|
setParameter(std::string("LaunchConfiguration.CreditSpecification"), launchConfigurationCreditSpecification);
|
|
}
|
|
|
|
CreateAutoProvisioningGroupRequest::LaunchConfigurationSystemDisk CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDisk() const {
|
|
return launchConfigurationSystemDisk_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDisk(const CreateAutoProvisioningGroupRequest::LaunchConfigurationSystemDisk &launchConfigurationSystemDisk) {
|
|
launchConfigurationSystemDisk_ = launchConfigurationSystemDisk;
|
|
setParameter(std::string("LaunchConfiguration.SystemDisk") + ".Encrypted", launchConfigurationSystemDisk.encrypted);
|
|
setParameter(std::string("LaunchConfiguration.SystemDisk") + ".KMSKeyId", launchConfigurationSystemDisk.kMSKeyId);
|
|
setParameter(std::string("LaunchConfiguration.SystemDisk") + ".EncryptAlgorithm", launchConfigurationSystemDisk.encryptAlgorithm);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationInstanceName() const {
|
|
return launchConfigurationInstanceName_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInstanceName(const std::string &launchConfigurationInstanceName) {
|
|
launchConfigurationInstanceName_ = launchConfigurationInstanceName;
|
|
setParameter(std::string("LaunchConfiguration.InstanceName"), launchConfigurationInstanceName);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationInstanceDescription() const {
|
|
return launchConfigurationInstanceDescription_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInstanceDescription(const std::string &launchConfigurationInstanceDescription) {
|
|
launchConfigurationInstanceDescription_ = launchConfigurationInstanceDescription;
|
|
setParameter(std::string("LaunchConfiguration.InstanceDescription"), launchConfigurationInstanceDescription);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getSpotAllocationStrategy() const {
|
|
return spotAllocationStrategy_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setSpotAllocationStrategy(const std::string &spotAllocationStrategy) {
|
|
spotAllocationStrategy_ = spotAllocationStrategy;
|
|
setParameter(std::string("SpotAllocationStrategy"), spotAllocationStrategy);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getRegionId() const {
|
|
return regionId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setRegionId(const std::string ®ionId) {
|
|
regionId_ = regionId;
|
|
setParameter(std::string("RegionId"), regionId);
|
|
}
|
|
|
|
bool CreateAutoProvisioningGroupRequest::getTerminateInstances() const {
|
|
return terminateInstances_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setTerminateInstances(bool terminateInstances) {
|
|
terminateInstances_ = terminateInstances;
|
|
setParameter(std::string("TerminateInstances"), terminateInstances ? "true" : "false");
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskName() const {
|
|
return launchConfigurationSystemDiskName_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskName(const std::string &launchConfigurationSystemDiskName) {
|
|
launchConfigurationSystemDiskName_ = launchConfigurationSystemDiskName;
|
|
setParameter(std::string("LaunchConfiguration.SystemDiskName"), launchConfigurationSystemDiskName);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskDescription() const {
|
|
return launchConfigurationSystemDiskDescription_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskDescription(const std::string &launchConfigurationSystemDiskDescription) {
|
|
launchConfigurationSystemDiskDescription_ = launchConfigurationSystemDiskDescription;
|
|
setParameter(std::string("LaunchConfiguration.SystemDiskDescription"), launchConfigurationSystemDiskDescription);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getExcessCapacityTerminationPolicy() const {
|
|
return excessCapacityTerminationPolicy_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setExcessCapacityTerminationPolicy(const std::string &excessCapacityTerminationPolicy) {
|
|
excessCapacityTerminationPolicy_ = excessCapacityTerminationPolicy;
|
|
setParameter(std::string("ExcessCapacityTerminationPolicy"), excessCapacityTerminationPolicy);
|
|
}
|
|
|
|
std::vector<CreateAutoProvisioningGroupRequest::LaunchTemplateConfig> CreateAutoProvisioningGroupRequest::getLaunchTemplateConfig() const {
|
|
return launchTemplateConfig_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchTemplateConfig(const std::vector<CreateAutoProvisioningGroupRequest::LaunchTemplateConfig> &launchTemplateConfig) {
|
|
launchTemplateConfig_ = launchTemplateConfig;
|
|
for(int dep1 = 0; dep1 != launchTemplateConfig.size(); dep1++) {
|
|
auto launchTemplateConfigObj = launchTemplateConfig.at(dep1);
|
|
std::string launchTemplateConfigObjStr = std::string("LaunchTemplateConfig") + "." + std::to_string(dep1 + 1);
|
|
setParameter(launchTemplateConfigObjStr + ".VSwitchId", launchTemplateConfigObj.vSwitchId);
|
|
setParameter(launchTemplateConfigObjStr + ".MaxPrice", std::to_string(launchTemplateConfigObj.maxPrice));
|
|
setParameter(launchTemplateConfigObjStr + ".Priority", std::to_string(launchTemplateConfigObj.priority));
|
|
setParameter(launchTemplateConfigObjStr + ".InstanceType", launchTemplateConfigObj.instanceType);
|
|
setParameter(launchTemplateConfigObjStr + ".WeightedCapacity", std::to_string(launchTemplateConfigObj.weightedCapacity));
|
|
}
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationRamRoleName() const {
|
|
return launchConfigurationRamRoleName_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationRamRoleName(const std::string &launchConfigurationRamRoleName) {
|
|
launchConfigurationRamRoleName_ = launchConfigurationRamRoleName;
|
|
setParameter(std::string("LaunchConfiguration.RamRoleName"), launchConfigurationRamRoleName);
|
|
}
|
|
|
|
int CreateAutoProvisioningGroupRequest::getLaunchConfigurationInternetMaxBandwidthIn() const {
|
|
return launchConfigurationInternetMaxBandwidthIn_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInternetMaxBandwidthIn(int launchConfigurationInternetMaxBandwidthIn) {
|
|
launchConfigurationInternetMaxBandwidthIn_ = launchConfigurationInternetMaxBandwidthIn;
|
|
setParameter(std::string("LaunchConfiguration.InternetMaxBandwidthIn"), std::to_string(launchConfigurationInternetMaxBandwidthIn));
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getSpotInstanceInterruptionBehavior() const {
|
|
return spotInstanceInterruptionBehavior_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setSpotInstanceInterruptionBehavior(const std::string &spotInstanceInterruptionBehavior) {
|
|
spotInstanceInterruptionBehavior_ = spotInstanceInterruptionBehavior;
|
|
setParameter(std::string("SpotInstanceInterruptionBehavior"), spotInstanceInterruptionBehavior);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSecurityEnhancementStrategy() const {
|
|
return launchConfigurationSecurityEnhancementStrategy_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSecurityEnhancementStrategy(const std::string &launchConfigurationSecurityEnhancementStrategy) {
|
|
launchConfigurationSecurityEnhancementStrategy_ = launchConfigurationSecurityEnhancementStrategy;
|
|
setParameter(std::string("LaunchConfiguration.SecurityEnhancementStrategy"), launchConfigurationSecurityEnhancementStrategy);
|
|
}
|
|
|
|
std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationTag> CreateAutoProvisioningGroupRequest::getLaunchConfigurationTag() const {
|
|
return launchConfigurationTag_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationTag(const std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationTag> &launchConfigurationTag) {
|
|
launchConfigurationTag_ = launchConfigurationTag;
|
|
for(int dep1 = 0; dep1 != launchConfigurationTag.size(); dep1++) {
|
|
auto launchConfigurationTagObj = launchConfigurationTag.at(dep1);
|
|
std::string launchConfigurationTagObjStr = std::string("LaunchConfiguration.Tag") + "." + std::to_string(dep1 + 1);
|
|
setParameter(launchConfigurationTagObjStr + ".Key", launchConfigurationTagObj.key);
|
|
setParameter(launchConfigurationTagObjStr + ".Value", launchConfigurationTagObj.value);
|
|
}
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationDeploymentSetId() const {
|
|
return launchConfigurationDeploymentSetId_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationDeploymentSetId(const std::string &launchConfigurationDeploymentSetId) {
|
|
launchConfigurationDeploymentSetId_ = launchConfigurationDeploymentSetId;
|
|
setParameter(std::string("LaunchConfiguration.DeploymentSetId"), launchConfigurationDeploymentSetId);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getResourceOwnerAccount() const {
|
|
return resourceOwnerAccount_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
|
|
resourceOwnerAccount_ = resourceOwnerAccount;
|
|
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getOwnerAccount() const {
|
|
return ownerAccount_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
|
|
ownerAccount_ = ownerAccount;
|
|
setParameter(std::string("OwnerAccount"), ownerAccount);
|
|
}
|
|
|
|
int CreateAutoProvisioningGroupRequest::getSpotInstancePoolsToUseCount() const {
|
|
return spotInstancePoolsToUseCount_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setSpotInstancePoolsToUseCount(int spotInstancePoolsToUseCount) {
|
|
spotInstancePoolsToUseCount_ = spotInstancePoolsToUseCount;
|
|
setParameter(std::string("SpotInstancePoolsToUseCount"), std::to_string(spotInstancePoolsToUseCount));
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationInternetChargeType() const {
|
|
return launchConfigurationInternetChargeType_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInternetChargeType(const std::string &launchConfigurationInternetChargeType) {
|
|
launchConfigurationInternetChargeType_ = launchConfigurationInternetChargeType;
|
|
setParameter(std::string("LaunchConfiguration.InternetChargeType"), launchConfigurationInternetChargeType);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchTemplateVersion() const {
|
|
return launchTemplateVersion_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchTemplateVersion(const std::string &launchTemplateVersion) {
|
|
launchTemplateVersion_ = launchTemplateVersion;
|
|
setParameter(std::string("LaunchTemplateVersion"), launchTemplateVersion);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationIoOptimized() const {
|
|
return launchConfigurationIoOptimized_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setLaunchConfigurationIoOptimized(const std::string &launchConfigurationIoOptimized) {
|
|
launchConfigurationIoOptimized_ = launchConfigurationIoOptimized;
|
|
setParameter(std::string("LaunchConfiguration.IoOptimized"), launchConfigurationIoOptimized);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getPayAsYouGoTargetCapacity() const {
|
|
return payAsYouGoTargetCapacity_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setPayAsYouGoTargetCapacity(const std::string &payAsYouGoTargetCapacity) {
|
|
payAsYouGoTargetCapacity_ = payAsYouGoTargetCapacity;
|
|
setParameter(std::string("PayAsYouGoTargetCapacity"), payAsYouGoTargetCapacity);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getTotalTargetCapacity() const {
|
|
return totalTargetCapacity_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setTotalTargetCapacity(const std::string &totalTargetCapacity) {
|
|
totalTargetCapacity_ = totalTargetCapacity;
|
|
setParameter(std::string("TotalTargetCapacity"), totalTargetCapacity);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getSpotTargetCapacity() const {
|
|
return spotTargetCapacity_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setSpotTargetCapacity(const std::string &spotTargetCapacity) {
|
|
spotTargetCapacity_ = spotTargetCapacity;
|
|
setParameter(std::string("SpotTargetCapacity"), spotTargetCapacity);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getValidFrom() const {
|
|
return validFrom_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setValidFrom(const std::string &validFrom) {
|
|
validFrom_ = validFrom;
|
|
setParameter(std::string("ValidFrom"), validFrom);
|
|
}
|
|
|
|
std::string CreateAutoProvisioningGroupRequest::getAutoProvisioningGroupName() const {
|
|
return autoProvisioningGroupName_;
|
|
}
|
|
|
|
void CreateAutoProvisioningGroupRequest::setAutoProvisioningGroupName(const std::string &autoProvisioningGroupName) {
|
|
autoProvisioningGroupName_ = autoProvisioningGroupName;
|
|
setParameter(std::string("AutoProvisioningGroupName"), autoProvisioningGroupName);
|
|
}
|
|
|