From 4a101f793442def80cdf0965bfc3b3faa9bc03b2 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Wed, 25 Nov 2020 02:37:28 +0000 Subject: [PATCH] Supported Primary NetworkInterface IP for API DescribeInstances. --- CHANGELOG | 3 + .../CreateAutoProvisioningGroupRequest.h | 129 +++++-- .../ecs/model/DescribeInstancesResult.h | 12 + ecs/src/EcsClient.cc | 6 +- .../CreateAutoProvisioningGroupRequest.cc | 353 ++++++++++++++++-- ecs/src/model/DescribeInstancesResult.cc | 20 + 6 files changed, 458 insertions(+), 65 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 8bddc9dc9..68ba1f03d 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-11-25 Version: patch +- Supported Primary NetworkInterface IP for API DescribeInstances. + 2020-11-24 Version: patch - Create TSDB Open api. diff --git a/ecs/include/alibabacloud/ecs/model/CreateAutoProvisioningGroupRequest.h b/ecs/include/alibabacloud/ecs/model/CreateAutoProvisioningGroupRequest.h index 296166a41..36dfa68ab 100644 --- a/ecs/include/alibabacloud/ecs/model/CreateAutoProvisioningGroupRequest.h +++ b/ecs/include/alibabacloud/ecs/model/CreateAutoProvisioningGroupRequest.h @@ -31,6 +31,19 @@ namespace AlibabaCloud class ALIBABACLOUD_ECS_EXPORT CreateAutoProvisioningGroupRequest : public RpcServiceRequest { public: + struct LaunchConfigurationDataDisk + { + int size; + std::string category; + }; + struct SystemDiskConfig + { + std::string diskCategory; + }; + struct DataDiskConfig + { + std::string diskCategory; + }; struct LaunchTemplateConfig { std::string instanceType; @@ -39,51 +52,104 @@ namespace AlibabaCloud double weightedCapacity; int priority; }; + struct LaunchConfigurationTag + { + std::string key; + std::string value; + }; public: CreateAutoProvisioningGroupRequest(); ~CreateAutoProvisioningGroupRequest(); + std::vector getLaunchConfigurationDataDisk()const; + void setLaunchConfigurationDataDisk(const std::vector& launchConfigurationDataDisk); long getResourceOwnerId()const; void setResourceOwnerId(long resourceOwnerId); + std::string getLaunchConfigurationSystemDiskCategory()const; + void setLaunchConfigurationSystemDiskCategory(const std::string& launchConfigurationSystemDiskCategory); std::string getAutoProvisioningGroupType()const; void setAutoProvisioningGroupType(const std::string& autoProvisioningGroupType); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getLaunchConfigurationImageId()const; + void setLaunchConfigurationImageId(const std::string& launchConfigurationImageId); + std::string getLaunchConfigurationResourceGroupId()const; + void setLaunchConfigurationResourceGroupId(const std::string& launchConfigurationResourceGroupId); + std::string getPayAsYouGoAllocationStrategy()const; + void setPayAsYouGoAllocationStrategy(const std::string& payAsYouGoAllocationStrategy); + std::string getDefaultTargetCapacityType()const; + void setDefaultTargetCapacityType(const std::string& defaultTargetCapacityType); + std::string getLaunchConfigurationKeyPairName()const; + void setLaunchConfigurationKeyPairName(const std::string& launchConfigurationKeyPairName); + std::vector getSystemDiskConfig()const; + void setSystemDiskConfig(const std::vector& systemDiskConfig); + std::vector getDataDiskConfig()const; + void setDataDiskConfig(const std::vector& dataDiskConfig); + std::string getValidUntil()const; + void setValidUntil(const std::string& validUntil); + std::string getLaunchTemplateId()const; + void setLaunchTemplateId(const std::string& launchTemplateId); + long getOwnerId()const; + void setOwnerId(long ownerId); + int getLaunchConfigurationSystemDiskSize()const; + void setLaunchConfigurationSystemDiskSize(int launchConfigurationSystemDiskSize); + int getLaunchConfigurationInternetMaxBandwidthOut()const; + void setLaunchConfigurationInternetMaxBandwidthOut(int launchConfigurationInternetMaxBandwidthOut); + std::string getLaunchConfigurationHostName()const; + void setLaunchConfigurationHostName(const std::string& launchConfigurationHostName); + float getMaxSpotPrice()const; + void setMaxSpotPrice(float maxSpotPrice); + bool getLaunchConfigurationPasswordInherit()const; + void setLaunchConfigurationPasswordInherit(bool launchConfigurationPasswordInherit); + std::string getLaunchConfigurationSecurityGroupId()const; + void setLaunchConfigurationSecurityGroupId(const std::string& launchConfigurationSecurityGroupId); std::string getDescription()const; void setDescription(const std::string& description); bool getTerminateInstancesWithExpiration()const; void setTerminateInstancesWithExpiration(bool terminateInstancesWithExpiration); - std::string getResourceGroupId()const; - void setResourceGroupId(const std::string& resourceGroupId); + std::string getLaunchConfigurationUserData()const; + void setLaunchConfigurationUserData(const std::string& launchConfigurationUserData); + std::string getLaunchConfigurationInstanceName()const; + void setLaunchConfigurationInstanceName(const std::string& launchConfigurationInstanceName); + std::string getLaunchConfigurationInstanceDescription()const; + void setLaunchConfigurationInstanceDescription(const std::string& launchConfigurationInstanceDescription); std::string getSpotAllocationStrategy()const; void setSpotAllocationStrategy(const std::string& spotAllocationStrategy); std::string getRegionId()const; void setRegionId(const std::string& regionId); bool getTerminateInstances()const; void setTerminateInstances(bool terminateInstances); - std::string getPayAsYouGoAllocationStrategy()const; - void setPayAsYouGoAllocationStrategy(const std::string& payAsYouGoAllocationStrategy); - std::string getDefaultTargetCapacityType()const; - void setDefaultTargetCapacityType(const std::string& defaultTargetCapacityType); + std::string getLaunchConfigurationSystemDiskName()const; + void setLaunchConfigurationSystemDiskName(const std::string& launchConfigurationSystemDiskName); + std::string getLaunchConfigurationSystemDiskDescription()const; + void setLaunchConfigurationSystemDiskDescription(const std::string& launchConfigurationSystemDiskDescription); std::string getExcessCapacityTerminationPolicy()const; void setExcessCapacityTerminationPolicy(const std::string& excessCapacityTerminationPolicy); std::vector getLaunchTemplateConfig()const; void setLaunchTemplateConfig(const std::vector& launchTemplateConfig); - std::string getValidUntil()const; - void setValidUntil(const std::string& validUntil); + std::string getLaunchConfigurationRamRoleName()const; + void setLaunchConfigurationRamRoleName(const std::string& launchConfigurationRamRoleName); + int getLaunchConfigurationInternetMaxBandwidthIn()const; + void setLaunchConfigurationInternetMaxBandwidthIn(int launchConfigurationInternetMaxBandwidthIn); std::string getSpotInstanceInterruptionBehavior()const; void setSpotInstanceInterruptionBehavior(const std::string& spotInstanceInterruptionBehavior); - std::string getLaunchTemplateId()const; - void setLaunchTemplateId(const std::string& launchTemplateId); + std::string getLaunchConfigurationSecurityEnhancementStrategy()const; + void setLaunchConfigurationSecurityEnhancementStrategy(const std::string& launchConfigurationSecurityEnhancementStrategy); + std::vector getLaunchConfigurationTag()const; + void setLaunchConfigurationTag(const std::vector& launchConfigurationTag); std::string getResourceOwnerAccount()const; void setResourceOwnerAccount(const std::string& resourceOwnerAccount); std::string getOwnerAccount()const; void setOwnerAccount(const std::string& ownerAccount); int getSpotInstancePoolsToUseCount()const; void setSpotInstancePoolsToUseCount(int spotInstancePoolsToUseCount); - long getOwnerId()const; - void setOwnerId(long ownerId); + std::string getLaunchConfigurationInternetChargeType()const; + void setLaunchConfigurationInternetChargeType(const std::string& launchConfigurationInternetChargeType); std::string getLaunchTemplateVersion()const; void setLaunchTemplateVersion(const std::string& launchTemplateVersion); + std::string getLaunchConfigurationIoOptimized()const; + void setLaunchConfigurationIoOptimized(const std::string& launchConfigurationIoOptimized); std::string getPayAsYouGoTargetCapacity()const; void setPayAsYouGoTargetCapacity(const std::string& payAsYouGoTargetCapacity); std::string getTotalTargetCapacity()const; @@ -94,36 +160,57 @@ namespace AlibabaCloud void setValidFrom(const std::string& validFrom); std::string getAutoProvisioningGroupName()const; void setAutoProvisioningGroupName(const std::string& autoProvisioningGroupName); - float getMaxSpotPrice()const; - void setMaxSpotPrice(float maxSpotPrice); private: + std::vector launchConfigurationDataDisk_; long resourceOwnerId_; + std::string launchConfigurationSystemDiskCategory_; std::string autoProvisioningGroupType_; + std::string resourceGroupId_; + std::string launchConfigurationImageId_; + std::string launchConfigurationResourceGroupId_; + std::string payAsYouGoAllocationStrategy_; + std::string defaultTargetCapacityType_; + std::string launchConfigurationKeyPairName_; + std::vector systemDiskConfig_; + std::vector dataDiskConfig_; + std::string validUntil_; + std::string launchTemplateId_; + long ownerId_; + int launchConfigurationSystemDiskSize_; + int launchConfigurationInternetMaxBandwidthOut_; + std::string launchConfigurationHostName_; + float maxSpotPrice_; + bool launchConfigurationPasswordInherit_; + std::string launchConfigurationSecurityGroupId_; std::string description_; bool terminateInstancesWithExpiration_; - std::string resourceGroupId_; + std::string launchConfigurationUserData_; + std::string launchConfigurationInstanceName_; + std::string launchConfigurationInstanceDescription_; std::string spotAllocationStrategy_; std::string regionId_; bool terminateInstances_; - std::string payAsYouGoAllocationStrategy_; - std::string defaultTargetCapacityType_; + std::string launchConfigurationSystemDiskName_; + std::string launchConfigurationSystemDiskDescription_; std::string excessCapacityTerminationPolicy_; std::vector launchTemplateConfig_; - std::string validUntil_; + std::string launchConfigurationRamRoleName_; + int launchConfigurationInternetMaxBandwidthIn_; std::string spotInstanceInterruptionBehavior_; - std::string launchTemplateId_; + std::string launchConfigurationSecurityEnhancementStrategy_; + std::vector launchConfigurationTag_; std::string resourceOwnerAccount_; std::string ownerAccount_; int spotInstancePoolsToUseCount_; - long ownerId_; + std::string launchConfigurationInternetChargeType_; std::string launchTemplateVersion_; + std::string launchConfigurationIoOptimized_; std::string payAsYouGoTargetCapacity_; std::string totalTargetCapacity_; std::string spotTargetCapacity_; std::string validFrom_; std::string autoProvisioningGroupName_; - float maxSpotPrice_; }; } diff --git a/ecs/include/alibabacloud/ecs/model/DescribeInstancesResult.h b/ecs/include/alibabacloud/ecs/model/DescribeInstancesResult.h index d3bc9c9d5..502bbd8a9 100644 --- a/ecs/include/alibabacloud/ecs/model/DescribeInstancesResult.h +++ b/ecs/include/alibabacloud/ecs/model/DescribeInstancesResult.h @@ -79,9 +79,21 @@ namespace AlibabaCloud }; struct NetworkInterface { + struct PrivateIpSet + { + std::string privateIpAddress; + bool primary; + }; + struct Ipv6Set + { + std::string ipv6Address; + }; + std::string type; + std::vector ipv6Sets; std::string primaryIpAddress; std::string networkInterfaceId; std::string macAddress; + std::vector privateIpSets; }; struct LockReason { diff --git a/ecs/src/EcsClient.cc b/ecs/src/EcsClient.cc index 4cac92263..e64210bdf 100644 --- a/ecs/src/EcsClient.cc +++ b/ecs/src/EcsClient.cc @@ -31,21 +31,21 @@ EcsClient::EcsClient(const Credentials &credentials, const ClientConfiguration & RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) { auto locationClient = std::make_shared(credentials, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ecs"); } EcsClient::EcsClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) { auto locationClient = std::make_shared(credentialsProvider, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ecs"); } EcsClient::EcsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) { auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "ecs"); } EcsClient::~EcsClient() diff --git a/ecs/src/model/CreateAutoProvisioningGroupRequest.cc b/ecs/src/model/CreateAutoProvisioningGroupRequest.cc index fbe7643cf..a074f94be 100644 --- a/ecs/src/model/CreateAutoProvisioningGroupRequest.cc +++ b/ecs/src/model/CreateAutoProvisioningGroupRequest.cc @@ -27,6 +27,22 @@ CreateAutoProvisioningGroupRequest::CreateAutoProvisioningGroupRequest() : CreateAutoProvisioningGroupRequest::~CreateAutoProvisioningGroupRequest() {} +std::vector CreateAutoProvisioningGroupRequest::getLaunchConfigurationDataDisk()const +{ + return launchConfigurationDataDisk_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationDataDisk(const std::vector& launchConfigurationDataDisk) +{ + launchConfigurationDataDisk_ = launchConfigurationDataDisk; + for(int dep1 = 0; dep1!= launchConfigurationDataDisk.size(); dep1++) { + auto launchConfigurationDataDiskObj = launchConfigurationDataDisk.at(dep1); + std::string launchConfigurationDataDiskObjStr = "LaunchConfiguration.DataDisk." + std::to_string(dep1 + 1); + setParameter(launchConfigurationDataDiskObjStr + ".Size", std::to_string(launchConfigurationDataDiskObj.size)); + setParameter(launchConfigurationDataDiskObjStr + ".Category", launchConfigurationDataDiskObj.category); + } +} + long CreateAutoProvisioningGroupRequest::getResourceOwnerId()const { return resourceOwnerId_; @@ -38,6 +54,17 @@ void CreateAutoProvisioningGroupRequest::setResourceOwnerId(long resourceOwnerId setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); } +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskCategory()const +{ + return launchConfigurationSystemDiskCategory_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskCategory(const std::string& launchConfigurationSystemDiskCategory) +{ + launchConfigurationSystemDiskCategory_ = launchConfigurationSystemDiskCategory; + setParameter("LaunchConfigurationSystemDiskCategory", launchConfigurationSystemDiskCategory); +} + std::string CreateAutoProvisioningGroupRequest::getAutoProvisioningGroupType()const { return autoProvisioningGroupType_; @@ -49,6 +76,201 @@ void CreateAutoProvisioningGroupRequest::setAutoProvisioningGroupType(const std: setParameter("AutoProvisioningGroupType", autoProvisioningGroupType); } +std::string CreateAutoProvisioningGroupRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void CreateAutoProvisioningGroupRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationImageId()const +{ + return launchConfigurationImageId_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationImageId(const std::string& launchConfigurationImageId) +{ + launchConfigurationImageId_ = launchConfigurationImageId; + setParameter("LaunchConfigurationImageId", launchConfigurationImageId); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationResourceGroupId()const +{ + return launchConfigurationResourceGroupId_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationResourceGroupId(const std::string& launchConfigurationResourceGroupId) +{ + launchConfigurationResourceGroupId_ = launchConfigurationResourceGroupId; + setParameter("LaunchConfigurationResourceGroupId", launchConfigurationResourceGroupId); +} + +std::string CreateAutoProvisioningGroupRequest::getPayAsYouGoAllocationStrategy()const +{ + return payAsYouGoAllocationStrategy_; +} + +void CreateAutoProvisioningGroupRequest::setPayAsYouGoAllocationStrategy(const std::string& payAsYouGoAllocationStrategy) +{ + payAsYouGoAllocationStrategy_ = payAsYouGoAllocationStrategy; + setParameter("PayAsYouGoAllocationStrategy", payAsYouGoAllocationStrategy); +} + +std::string CreateAutoProvisioningGroupRequest::getDefaultTargetCapacityType()const +{ + return defaultTargetCapacityType_; +} + +void CreateAutoProvisioningGroupRequest::setDefaultTargetCapacityType(const std::string& defaultTargetCapacityType) +{ + defaultTargetCapacityType_ = defaultTargetCapacityType; + setParameter("DefaultTargetCapacityType", defaultTargetCapacityType); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationKeyPairName()const +{ + return launchConfigurationKeyPairName_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationKeyPairName(const std::string& launchConfigurationKeyPairName) +{ + launchConfigurationKeyPairName_ = launchConfigurationKeyPairName; + setParameter("LaunchConfigurationKeyPairName", launchConfigurationKeyPairName); +} + +std::vector CreateAutoProvisioningGroupRequest::getSystemDiskConfig()const +{ + return systemDiskConfig_; +} + +void CreateAutoProvisioningGroupRequest::setSystemDiskConfig(const std::vector& systemDiskConfig) +{ + systemDiskConfig_ = systemDiskConfig; + for(int dep1 = 0; dep1!= systemDiskConfig.size(); dep1++) { + auto systemDiskConfigObj = systemDiskConfig.at(dep1); + std::string systemDiskConfigObjStr = "SystemDiskConfig." + std::to_string(dep1 + 1); + setParameter(systemDiskConfigObjStr + ".DiskCategory", systemDiskConfigObj.diskCategory); + } +} + +std::vector CreateAutoProvisioningGroupRequest::getDataDiskConfig()const +{ + return dataDiskConfig_; +} + +void CreateAutoProvisioningGroupRequest::setDataDiskConfig(const std::vector& dataDiskConfig) +{ + dataDiskConfig_ = dataDiskConfig; + for(int dep1 = 0; dep1!= dataDiskConfig.size(); dep1++) { + auto dataDiskConfigObj = dataDiskConfig.at(dep1); + std::string dataDiskConfigObjStr = "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("ValidUntil", validUntil); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchTemplateId()const +{ + return launchTemplateId_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchTemplateId(const std::string& launchTemplateId) +{ + launchTemplateId_ = launchTemplateId; + setParameter("LaunchTemplateId", launchTemplateId); +} + +long CreateAutoProvisioningGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateAutoProvisioningGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +int CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskSize()const +{ + return launchConfigurationSystemDiskSize_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskSize(int launchConfigurationSystemDiskSize) +{ + launchConfigurationSystemDiskSize_ = launchConfigurationSystemDiskSize; + setParameter("LaunchConfigurationSystemDiskSize", std::to_string(launchConfigurationSystemDiskSize)); +} + +int CreateAutoProvisioningGroupRequest::getLaunchConfigurationInternetMaxBandwidthOut()const +{ + return launchConfigurationInternetMaxBandwidthOut_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInternetMaxBandwidthOut(int launchConfigurationInternetMaxBandwidthOut) +{ + launchConfigurationInternetMaxBandwidthOut_ = launchConfigurationInternetMaxBandwidthOut; + setParameter("LaunchConfigurationInternetMaxBandwidthOut", std::to_string(launchConfigurationInternetMaxBandwidthOut)); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationHostName()const +{ + return launchConfigurationHostName_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationHostName(const std::string& launchConfigurationHostName) +{ + launchConfigurationHostName_ = launchConfigurationHostName; + setParameter("LaunchConfigurationHostName", launchConfigurationHostName); +} + +float CreateAutoProvisioningGroupRequest::getMaxSpotPrice()const +{ + return maxSpotPrice_; +} + +void CreateAutoProvisioningGroupRequest::setMaxSpotPrice(float maxSpotPrice) +{ + maxSpotPrice_ = maxSpotPrice; + setParameter("MaxSpotPrice", std::to_string(maxSpotPrice)); +} + +bool CreateAutoProvisioningGroupRequest::getLaunchConfigurationPasswordInherit()const +{ + return launchConfigurationPasswordInherit_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationPasswordInherit(bool launchConfigurationPasswordInherit) +{ + launchConfigurationPasswordInherit_ = launchConfigurationPasswordInherit; + setParameter("LaunchConfigurationPasswordInherit", launchConfigurationPasswordInherit ? "true" : "false"); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSecurityGroupId()const +{ + return launchConfigurationSecurityGroupId_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSecurityGroupId(const std::string& launchConfigurationSecurityGroupId) +{ + launchConfigurationSecurityGroupId_ = launchConfigurationSecurityGroupId; + setParameter("LaunchConfigurationSecurityGroupId", launchConfigurationSecurityGroupId); +} + std::string CreateAutoProvisioningGroupRequest::getDescription()const { return description_; @@ -71,15 +293,37 @@ void CreateAutoProvisioningGroupRequest::setTerminateInstancesWithExpiration(boo setParameter("TerminateInstancesWithExpiration", terminateInstancesWithExpiration ? "true" : "false"); } -std::string CreateAutoProvisioningGroupRequest::getResourceGroupId()const +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationUserData()const { - return resourceGroupId_; + return launchConfigurationUserData_; } -void CreateAutoProvisioningGroupRequest::setResourceGroupId(const std::string& resourceGroupId) +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationUserData(const std::string& launchConfigurationUserData) { - resourceGroupId_ = resourceGroupId; - setParameter("ResourceGroupId", resourceGroupId); + launchConfigurationUserData_ = launchConfigurationUserData; + setParameter("LaunchConfigurationUserData", launchConfigurationUserData); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationInstanceName()const +{ + return launchConfigurationInstanceName_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInstanceName(const std::string& launchConfigurationInstanceName) +{ + launchConfigurationInstanceName_ = launchConfigurationInstanceName; + setParameter("LaunchConfigurationInstanceName", launchConfigurationInstanceName); +} + +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationInstanceDescription()const +{ + return launchConfigurationInstanceDescription_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInstanceDescription(const std::string& launchConfigurationInstanceDescription) +{ + launchConfigurationInstanceDescription_ = launchConfigurationInstanceDescription; + setParameter("LaunchConfigurationInstanceDescription", launchConfigurationInstanceDescription); } std::string CreateAutoProvisioningGroupRequest::getSpotAllocationStrategy()const @@ -115,26 +359,26 @@ void CreateAutoProvisioningGroupRequest::setTerminateInstances(bool terminateIns setParameter("TerminateInstances", terminateInstances ? "true" : "false"); } -std::string CreateAutoProvisioningGroupRequest::getPayAsYouGoAllocationStrategy()const +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskName()const { - return payAsYouGoAllocationStrategy_; + return launchConfigurationSystemDiskName_; } -void CreateAutoProvisioningGroupRequest::setPayAsYouGoAllocationStrategy(const std::string& payAsYouGoAllocationStrategy) +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskName(const std::string& launchConfigurationSystemDiskName) { - payAsYouGoAllocationStrategy_ = payAsYouGoAllocationStrategy; - setParameter("PayAsYouGoAllocationStrategy", payAsYouGoAllocationStrategy); + launchConfigurationSystemDiskName_ = launchConfigurationSystemDiskName; + setParameter("LaunchConfigurationSystemDiskName", launchConfigurationSystemDiskName); } -std::string CreateAutoProvisioningGroupRequest::getDefaultTargetCapacityType()const +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSystemDiskDescription()const { - return defaultTargetCapacityType_; + return launchConfigurationSystemDiskDescription_; } -void CreateAutoProvisioningGroupRequest::setDefaultTargetCapacityType(const std::string& defaultTargetCapacityType) +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskDescription(const std::string& launchConfigurationSystemDiskDescription) { - defaultTargetCapacityType_ = defaultTargetCapacityType; - setParameter("DefaultTargetCapacityType", defaultTargetCapacityType); + launchConfigurationSystemDiskDescription_ = launchConfigurationSystemDiskDescription; + setParameter("LaunchConfigurationSystemDiskDescription", launchConfigurationSystemDiskDescription); } std::string CreateAutoProvisioningGroupRequest::getExcessCapacityTerminationPolicy()const @@ -167,15 +411,26 @@ void CreateAutoProvisioningGroupRequest::setLaunchTemplateConfig(const std::vect } } -std::string CreateAutoProvisioningGroupRequest::getValidUntil()const +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationRamRoleName()const { - return validUntil_; + return launchConfigurationRamRoleName_; } -void CreateAutoProvisioningGroupRequest::setValidUntil(const std::string& validUntil) +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationRamRoleName(const std::string& launchConfigurationRamRoleName) { - validUntil_ = validUntil; - setParameter("ValidUntil", validUntil); + launchConfigurationRamRoleName_ = launchConfigurationRamRoleName; + setParameter("LaunchConfigurationRamRoleName", launchConfigurationRamRoleName); +} + +int CreateAutoProvisioningGroupRequest::getLaunchConfigurationInternetMaxBandwidthIn()const +{ + return launchConfigurationInternetMaxBandwidthIn_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInternetMaxBandwidthIn(int launchConfigurationInternetMaxBandwidthIn) +{ + launchConfigurationInternetMaxBandwidthIn_ = launchConfigurationInternetMaxBandwidthIn; + setParameter("LaunchConfigurationInternetMaxBandwidthIn", std::to_string(launchConfigurationInternetMaxBandwidthIn)); } std::string CreateAutoProvisioningGroupRequest::getSpotInstanceInterruptionBehavior()const @@ -189,15 +444,31 @@ void CreateAutoProvisioningGroupRequest::setSpotInstanceInterruptionBehavior(con setParameter("SpotInstanceInterruptionBehavior", spotInstanceInterruptionBehavior); } -std::string CreateAutoProvisioningGroupRequest::getLaunchTemplateId()const +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationSecurityEnhancementStrategy()const { - return launchTemplateId_; + return launchConfigurationSecurityEnhancementStrategy_; } -void CreateAutoProvisioningGroupRequest::setLaunchTemplateId(const std::string& launchTemplateId) +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSecurityEnhancementStrategy(const std::string& launchConfigurationSecurityEnhancementStrategy) { - launchTemplateId_ = launchTemplateId; - setParameter("LaunchTemplateId", launchTemplateId); + launchConfigurationSecurityEnhancementStrategy_ = launchConfigurationSecurityEnhancementStrategy; + setParameter("LaunchConfigurationSecurityEnhancementStrategy", launchConfigurationSecurityEnhancementStrategy); +} + +std::vector CreateAutoProvisioningGroupRequest::getLaunchConfigurationTag()const +{ + return launchConfigurationTag_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationTag(const std::vector& launchConfigurationTag) +{ + launchConfigurationTag_ = launchConfigurationTag; + for(int dep1 = 0; dep1!= launchConfigurationTag.size(); dep1++) { + auto launchConfigurationTagObj = launchConfigurationTag.at(dep1); + std::string launchConfigurationTagObjStr = "LaunchConfiguration.Tag." + std::to_string(dep1 + 1); + setParameter(launchConfigurationTagObjStr + ".Key", launchConfigurationTagObj.key); + setParameter(launchConfigurationTagObjStr + ".Value", launchConfigurationTagObj.value); + } } std::string CreateAutoProvisioningGroupRequest::getResourceOwnerAccount()const @@ -233,15 +504,15 @@ void CreateAutoProvisioningGroupRequest::setSpotInstancePoolsToUseCount(int spot setParameter("SpotInstancePoolsToUseCount", std::to_string(spotInstancePoolsToUseCount)); } -long CreateAutoProvisioningGroupRequest::getOwnerId()const +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationInternetChargeType()const { - return ownerId_; + return launchConfigurationInternetChargeType_; } -void CreateAutoProvisioningGroupRequest::setOwnerId(long ownerId) +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationInternetChargeType(const std::string& launchConfigurationInternetChargeType) { - ownerId_ = ownerId; - setParameter("OwnerId", std::to_string(ownerId)); + launchConfigurationInternetChargeType_ = launchConfigurationInternetChargeType; + setParameter("LaunchConfigurationInternetChargeType", launchConfigurationInternetChargeType); } std::string CreateAutoProvisioningGroupRequest::getLaunchTemplateVersion()const @@ -255,6 +526,17 @@ void CreateAutoProvisioningGroupRequest::setLaunchTemplateVersion(const std::str setParameter("LaunchTemplateVersion", launchTemplateVersion); } +std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationIoOptimized()const +{ + return launchConfigurationIoOptimized_; +} + +void CreateAutoProvisioningGroupRequest::setLaunchConfigurationIoOptimized(const std::string& launchConfigurationIoOptimized) +{ + launchConfigurationIoOptimized_ = launchConfigurationIoOptimized; + setParameter("LaunchConfigurationIoOptimized", launchConfigurationIoOptimized); +} + std::string CreateAutoProvisioningGroupRequest::getPayAsYouGoTargetCapacity()const { return payAsYouGoTargetCapacity_; @@ -310,14 +592,3 @@ void CreateAutoProvisioningGroupRequest::setAutoProvisioningGroupName(const std: setParameter("AutoProvisioningGroupName", autoProvisioningGroupName); } -float CreateAutoProvisioningGroupRequest::getMaxSpotPrice()const -{ - return maxSpotPrice_; -} - -void CreateAutoProvisioningGroupRequest::setMaxSpotPrice(float maxSpotPrice) -{ - maxSpotPrice_ = maxSpotPrice; - setParameter("MaxSpotPrice", std::to_string(maxSpotPrice)); -} - diff --git a/ecs/src/model/DescribeInstancesResult.cc b/ecs/src/model/DescribeInstancesResult.cc index ab465a9d0..aad0f24dd 100644 --- a/ecs/src/model/DescribeInstancesResult.cc +++ b/ecs/src/model/DescribeInstancesResult.cc @@ -147,6 +147,26 @@ void DescribeInstancesResult::parse(const std::string &payload) networkInterfacesObject.macAddress = valueInstancesInstanceNetworkInterfacesNetworkInterface["MacAddress"].asString(); if(!valueInstancesInstanceNetworkInterfacesNetworkInterface["PrimaryIpAddress"].isNull()) networkInterfacesObject.primaryIpAddress = valueInstancesInstanceNetworkInterfacesNetworkInterface["PrimaryIpAddress"].asString(); + if(!valueInstancesInstanceNetworkInterfacesNetworkInterface["Type"].isNull()) + networkInterfacesObject.type = valueInstancesInstanceNetworkInterfacesNetworkInterface["Type"].asString(); + auto allPrivateIpSetsNode = valueInstancesInstanceNetworkInterfacesNetworkInterface["PrivateIpSets"]["PrivateIpSet"]; + for (auto valueInstancesInstanceNetworkInterfacesNetworkInterfacePrivateIpSetsPrivateIpSet : allPrivateIpSetsNode) + { + Instance::NetworkInterface::PrivateIpSet privateIpSetsObject; + if(!valueInstancesInstanceNetworkInterfacesNetworkInterfacePrivateIpSetsPrivateIpSet["PrivateIpAddress"].isNull()) + privateIpSetsObject.privateIpAddress = valueInstancesInstanceNetworkInterfacesNetworkInterfacePrivateIpSetsPrivateIpSet["PrivateIpAddress"].asString(); + if(!valueInstancesInstanceNetworkInterfacesNetworkInterfacePrivateIpSetsPrivateIpSet["Primary"].isNull()) + privateIpSetsObject.primary = valueInstancesInstanceNetworkInterfacesNetworkInterfacePrivateIpSetsPrivateIpSet["Primary"].asString() == "true"; + networkInterfacesObject.privateIpSets.push_back(privateIpSetsObject); + } + auto allIpv6SetsNode = valueInstancesInstanceNetworkInterfacesNetworkInterface["Ipv6Sets"]["Ipv6Set"]; + for (auto valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6SetsIpv6Set : allIpv6SetsNode) + { + Instance::NetworkInterface::Ipv6Set ipv6SetsObject; + if(!valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6SetsIpv6Set["Ipv6Address"].isNull()) + ipv6SetsObject.ipv6Address = valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6SetsIpv6Set["Ipv6Address"].asString(); + networkInterfacesObject.ipv6Sets.push_back(ipv6SetsObject); + } instancesObject.networkInterfaces.push_back(networkInterfacesObject); } auto allOperationLocksNode = valueInstancesInstance["OperationLocks"]["LockReason"];