Supported Primary NetworkInterface IP for API DescribeInstances.

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.
 

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<LaunchConfigurationDataDisk> getLaunchConfigurationDataDisk()const;
+				void setLaunchConfigurationDataDisk(const std::vector<LaunchConfigurationDataDisk>& 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<SystemDiskConfig> getSystemDiskConfig()const;
+				void setSystemDiskConfig(const std::vector<SystemDiskConfig>& systemDiskConfig);
+				std::vector<DataDiskConfig> getDataDiskConfig()const;
+				void setDataDiskConfig(const std::vector<DataDiskConfig>& 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<LaunchTemplateConfig> getLaunchTemplateConfig()const;
 				void setLaunchTemplateConfig(const std::vector<LaunchTemplateConfig>& 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<LaunchConfigurationTag> getLaunchConfigurationTag()const;
+				void setLaunchConfigurationTag(const std::vector<LaunchConfigurationTag>& 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> 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> systemDiskConfig_;
+				std::vector<DataDiskConfig> 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> launchTemplateConfig_;
-				std::string validUntil_;
+				std::string launchConfigurationRamRoleName_;
+				int launchConfigurationInternetMaxBandwidthIn_;
 				std::string spotInstanceInterruptionBehavior_;
-				std::string launchTemplateId_;
+				std::string launchConfigurationSecurityEnhancementStrategy_;
+				std::vector<LaunchConfigurationTag> 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_;
 
 			};
 		}

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<NetworkInterface::Ipv6Set> ipv6Sets;
 						std::string primaryIpAddress;
 						std::string networkInterfaceId;
 						std::string macAddress;
+						std::vector<NetworkInterface::PrivateIpSet> privateIpSets;
 					};
 					struct LockReason
 					{

ecs/src/EcsClient.cc

@@ -31,21 +31,21 @@ EcsClient::EcsClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ecs");
 }
 
 EcsClient::EcsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(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<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ecs");
 }
 
 EcsClient::~EcsClient()

ecs/src/model/CreateAutoProvisioningGroupRequest.cc

@@ -27,6 +27,22 @@ CreateAutoProvisioningGroupRequest::CreateAutoProvisioningGroupRequest() :
 CreateAutoProvisioningGroupRequest::~CreateAutoProvisioningGroupRequest()
 {}
 
+std::vector<CreateAutoProvisioningGroupRequest::LaunchConfigurationDataDisk> CreateAutoProvisioningGroupRequest::getLaunchConfigurationDataDisk()const
+{
+	return launchConfigurationDataDisk_;
+}
+
+void CreateAutoProvisioningGroupRequest::setLaunchConfigurationDataDisk(const std::vector<LaunchConfigurationDataDisk>& 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::SystemDiskConfig> CreateAutoProvisioningGroupRequest::getSystemDiskConfig()const
+{
+	return systemDiskConfig_;
+}
+
+void CreateAutoProvisioningGroupRequest::setSystemDiskConfig(const std::vector<SystemDiskConfig>& 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::DataDiskConfig> CreateAutoProvisioningGroupRequest::getDataDiskConfig()const
+{
+	return dataDiskConfig_;
+}
+
+void CreateAutoProvisioningGroupRequest::setDataDiskConfig(const std::vector<DataDiskConfig>& 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::LaunchConfigurationTag> CreateAutoProvisioningGroupRequest::getLaunchConfigurationTag()const
+{
+	return launchConfigurationTag_;
+}
+
+void CreateAutoProvisioningGroupRequest::setLaunchConfigurationTag(const std::vector<LaunchConfigurationTag>& 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));
-}
-

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"];