Generated 2019-06-01 for smc.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-11-12 Version: patch
+- Generated 2019-06-01 for `smc`.
+
 2020-11-12 Version: patch
 - Update new version.
 

smc/include/alibabacloud/smc/model/CreateReplicationJobRequest.h

@@ -36,9 +36,22 @@ namespace AlibabaCloud
 					std::string value;
 					std::string key;
 				};
+				struct SystemDiskPart
+				{
+					long sizeBytes;
+					bool block;
+					std::string device;
+				};
 				struct DataDisk
 				{
 					int size;
+					struct Part
+					{
+						long sizeBytes;
+						bool block;
+						std::string device;
+					};
+					std::vector<Part> part;
 					int index;
 				};
 
@@ -46,86 +59,101 @@ namespace AlibabaCloud
 				CreateReplicationJobRequest();
 				~CreateReplicationJobRequest();
 
-				std::string getTargetType()const;
-				void setTargetType(const std::string& targetType);
-				std::string getClientToken()const;
-				void setClientToken(const std::string& clientToken);
-				std::string getDescription()const;
-				void setDescription(const std::string& description);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
 				int getFrequency()const;
 				void setFrequency(int frequency);
 				std::string getReplicationParameters()const;
 				void setReplicationParameters(const std::string& replicationParameters);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
-				std::string getImageName()const;
-				void setImageName(const std::string& imageName);
 				int getSystemDiskSize()const;
 				void setSystemDiskSize(int systemDiskSize);
-				std::string getInstanceType()const;
-				void setInstanceType(const std::string& instanceType);
 				std::vector<Tag> getTag()const;
 				void setTag(const std::vector<Tag>& tag);
 				int getNetMode()const;
 				void setNetMode(int netMode);
-				std::string getSourceId()const;
-				void setSourceId(const std::string& sourceId);
-				bool getRunOnce()const;
-				void setRunOnce(bool runOnce);
+				std::string getContainerNamespace()const;
+				void setContainerNamespace(const std::string& containerNamespace);
 				std::string getLaunchTemplateId()const;
 				void setLaunchTemplateId(const std::string& launchTemplateId);
-				std::string getResourceOwnerAccount()const;
-				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getValidTime()const;
 				void setValidTime(const std::string& validTime);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::vector<DataDisk> getDataDisk()const;
-				void setDataDisk(const std::vector<DataDisk>& dataDisk);
-				std::string getLaunchTemplateVersion()const;
-				void setLaunchTemplateVersion(const std::string& launchTemplateVersion);
 				std::string getVSwitchId()const;
 				void setVSwitchId(const std::string& vSwitchId);
 				std::string getScheduledStartTime()const;
 				void setScheduledStartTime(const std::string& scheduledStartTime);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
-				std::string getVpcId()const;
-				void setVpcId(const std::string& vpcId);
+				std::string getInstanceRamRole()const;
+				void setInstanceRamRole(const std::string& instanceRamRole);
 				std::string getName()const;
 				void setName(const std::string& name);
 				int getMaxNumberOfImageToKeep()const;
 				void setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep);
+				std::string getTargetType()const;
+				void setTargetType(const std::string& targetType);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getImageName()const;
+				void setImageName(const std::string& imageName);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+				std::string getContainerRepository()const;
+				void setContainerRepository(const std::string& containerRepository);
+				std::string getContainerTag()const;
+				void setContainerTag(const std::string& containerTag);
+				std::string getSourceId()const;
+				void setSourceId(const std::string& sourceId);
+				bool getRunOnce()const;
+				void setRunOnce(bool runOnce);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::vector<SystemDiskPart> getSystemDiskPart()const;
+				void setSystemDiskPart(const std::vector<SystemDiskPart>& systemDiskPart);
+				std::vector<DataDisk> getDataDisk()const;
+				void setDataDisk(const std::vector<DataDisk>& dataDisk);
+				std::string getLaunchTemplateVersion()const;
+				void setLaunchTemplateVersion(const std::string& launchTemplateVersion);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
 
             private:
-				std::string targetType_;
-				std::string clientToken_;
-				std::string description_;
-				std::string accessKeyId_;
 				int frequency_;
 				std::string replicationParameters_;
-				std::string regionId_;
-				std::string imageName_;
 				int systemDiskSize_;
-				std::string instanceType_;
 				std::vector<Tag> tag_;
 				int netMode_;
-				std::string sourceId_;
-				bool runOnce_;
+				std::string containerNamespace_;
 				std::string launchTemplateId_;
-				std::string resourceOwnerAccount_;
 				std::string validTime_;
 				long ownerId_;
-				std::vector<DataDisk> dataDisk_;
-				std::string launchTemplateVersion_;
 				std::string vSwitchId_;
 				std::string scheduledStartTime_;
 				std::string instanceId_;
-				std::string vpcId_;
+				std::string instanceRamRole_;
 				std::string name_;
 				int maxNumberOfImageToKeep_;
+				std::string targetType_;
+				std::string clientToken_;
+				std::string description_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string imageName_;
+				std::string instanceType_;
+				std::string containerRepository_;
+				std::string containerTag_;
+				std::string sourceId_;
+				bool runOnce_;
+				std::string resourceOwnerAccount_;
+				std::vector<SystemDiskPart> systemDiskPart_;
+				std::vector<DataDisk> dataDisk_;
+				std::string launchTemplateVersion_;
+				std::string vpcId_;
 
 			};
 		}

smc/include/alibabacloud/smc/model/DescribeReplicationJobsResult.h

@@ -34,8 +34,21 @@ namespace AlibabaCloud
 			public:
 				struct ReplicationJob
 				{
+					struct SystemDiskPart
+					{
+						std::string device;
+						bool block;
+						long sizeBytes;
+					};
 					struct DataDisk
 					{
+						struct Part
+						{
+							std::string device;
+							bool block;
+							long sizeBytes;
+						};
+						std::vector<DataDisk::Part> parts;
 						int size;
 						int index;
 					};
@@ -52,12 +65,16 @@ namespace AlibabaCloud
 					std::string transitionInstanceId;
 					int systemDiskSize;
 					int netMode;
+					std::vector<ReplicationJob::SystemDiskPart> systemDiskParts;
 					std::string sourceId;
+					std::string containerTag;
 					std::string businessStatus;
 					std::string name;
 					std::string validTime;
 					int maxNumberOfImageToKeep;
 					bool runOnce;
+					std::string instanceRamRole;
+					std::string containerRepository;
 					std::string targetType;
 					std::string imageId;
 					std::string instanceType;
@@ -73,6 +90,7 @@ namespace AlibabaCloud
 					std::string imageName;
 					std::string vpcId;
 					std::string statusInfo;
+					std::string containerNamespace;
 					std::string creationTime;
 					std::string launchTemplateVersion;
 					int frequency;

smc/include/alibabacloud/smc/model/DescribeSourceServersResult.h

@@ -36,10 +36,27 @@ namespace AlibabaCloud
 				{
 					struct DataDisk
 					{
+						struct Part
+						{
+							std::string path;
+							bool need;
+							std::string device;
+							bool canBlock;
+							long sizeBytes;
+						};
 						std::string path;
+						std::vector<DataDisk::Part> parts;
 						int size;
 						int index;
 					};
+					struct SystemDiskPart
+					{
+						std::string path;
+						bool need;
+						std::string device;
+						bool canBlock;
+						long sizeBytes;
+					};
 					std::string description;
 					std::string systemInfo;
 					std::vector<SourceServer::DataDisk> dataDisks;
@@ -47,6 +64,7 @@ namespace AlibabaCloud
 					std::string architecture;
 					std::string agentVersion;
 					int systemDiskSize;
+					std::vector<SourceServer::SystemDiskPart> systemDiskParts;
 					std::string sourceId;
 					std::string name;
 					int kernelLevel;

smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h

@@ -31,9 +31,22 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_SMC_EXPORT ModifyReplicationJobAttributeRequest : public RpcServiceRequest
 			{
 			public:
+				struct SystemDiskPart
+				{
+					long sizeBytes;
+					bool block;
+					std::string device;
+				};
 				struct DataDisk
 				{
 					int size;
+					struct Part
+					{
+						long sizeBytes;
+						bool block;
+						std::string device;
+					};
+					std::vector<Part> part;
 					int index;
 				};
 
@@ -57,10 +70,20 @@ namespace AlibabaCloud
 				void setSystemDiskSize(int systemDiskSize);
 				std::string getInstanceType()const;
 				void setInstanceType(const std::string& instanceType);
+				std::string getContainerRepository()const;
+				void setContainerRepository(const std::string& containerRepository);
+				std::string getContainerTag()const;
+				void setContainerTag(const std::string& containerTag);
+				std::string getContainerNamespace()const;
+				void setContainerNamespace(const std::string& containerNamespace);
 				std::string getLaunchTemplateId()const;
 				void setLaunchTemplateId(const std::string& launchTemplateId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::vector<SystemDiskPart> getSystemDiskPart()const;
+				void setSystemDiskPart(const std::vector<SystemDiskPart>& systemDiskPart);
+				std::string getValidTime()const;
+				void setValidTime(const std::string& validTime);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::vector<DataDisk> getDataDisk()const;
@@ -71,6 +94,8 @@ namespace AlibabaCloud
 				void setScheduledStartTime(const std::string& scheduledStartTime);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
+				std::string getInstanceRamRole()const;
+				void setInstanceRamRole(const std::string& instanceRamRole);
 				std::string getName()const;
 				void setName(const std::string& name);
 				int getMaxNumberOfImageToKeep()const;
@@ -85,13 +110,19 @@ namespace AlibabaCloud
 				std::string imageName_;
 				int systemDiskSize_;
 				std::string instanceType_;
+				std::string containerRepository_;
+				std::string containerTag_;
+				std::string containerNamespace_;
 				std::string launchTemplateId_;
 				std::string resourceOwnerAccount_;
+				std::vector<SystemDiskPart> systemDiskPart_;
+				std::string validTime_;
 				long ownerId_;
 				std::vector<DataDisk> dataDisk_;
 				std::string launchTemplateVersion_;
 				std::string scheduledStartTime_;
 				std::string instanceId_;
+				std::string instanceRamRole_;
 				std::string name_;
 				int maxNumberOfImageToKeep_;
 

smc/src/model/CreateReplicationJobRequest.cc

@@ -27,6 +27,176 @@ CreateReplicationJobRequest::CreateReplicationJobRequest() :
 CreateReplicationJobRequest::~CreateReplicationJobRequest()
 {}
 
+int CreateReplicationJobRequest::getFrequency()const
+{
+	return frequency_;
+}
+
+void CreateReplicationJobRequest::setFrequency(int frequency)
+{
+	frequency_ = frequency;
+	setParameter("Frequency", std::to_string(frequency));
+}
+
+std::string CreateReplicationJobRequest::getReplicationParameters()const
+{
+	return replicationParameters_;
+}
+
+void CreateReplicationJobRequest::setReplicationParameters(const std::string& replicationParameters)
+{
+	replicationParameters_ = replicationParameters;
+	setParameter("ReplicationParameters", replicationParameters);
+}
+
+int CreateReplicationJobRequest::getSystemDiskSize()const
+{
+	return systemDiskSize_;
+}
+
+void CreateReplicationJobRequest::setSystemDiskSize(int systemDiskSize)
+{
+	systemDiskSize_ = systemDiskSize;
+	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
+}
+
+std::vector<CreateReplicationJobRequest::Tag> CreateReplicationJobRequest::getTag()const
+{
+	return tag_;
+}
+
+void CreateReplicationJobRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+	}
+}
+
+int CreateReplicationJobRequest::getNetMode()const
+{
+	return netMode_;
+}
+
+void CreateReplicationJobRequest::setNetMode(int netMode)
+{
+	netMode_ = netMode;
+	setParameter("NetMode", std::to_string(netMode));
+}
+
+std::string CreateReplicationJobRequest::getContainerNamespace()const
+{
+	return containerNamespace_;
+}
+
+void CreateReplicationJobRequest::setContainerNamespace(const std::string& containerNamespace)
+{
+	containerNamespace_ = containerNamespace;
+	setParameter("ContainerNamespace", containerNamespace);
+}
+
+std::string CreateReplicationJobRequest::getLaunchTemplateId()const
+{
+	return launchTemplateId_;
+}
+
+void CreateReplicationJobRequest::setLaunchTemplateId(const std::string& launchTemplateId)
+{
+	launchTemplateId_ = launchTemplateId;
+	setParameter("LaunchTemplateId", launchTemplateId);
+}
+
+std::string CreateReplicationJobRequest::getValidTime()const
+{
+	return validTime_;
+}
+
+void CreateReplicationJobRequest::setValidTime(const std::string& validTime)
+{
+	validTime_ = validTime;
+	setParameter("ValidTime", validTime);
+}
+
+long CreateReplicationJobRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateReplicationJobRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateReplicationJobRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateReplicationJobRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateReplicationJobRequest::getScheduledStartTime()const
+{
+	return scheduledStartTime_;
+}
+
+void CreateReplicationJobRequest::setScheduledStartTime(const std::string& scheduledStartTime)
+{
+	scheduledStartTime_ = scheduledStartTime;
+	setParameter("ScheduledStartTime", scheduledStartTime);
+}
+
+std::string CreateReplicationJobRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void CreateReplicationJobRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string CreateReplicationJobRequest::getInstanceRamRole()const
+{
+	return instanceRamRole_;
+}
+
+void CreateReplicationJobRequest::setInstanceRamRole(const std::string& instanceRamRole)
+{
+	instanceRamRole_ = instanceRamRole;
+	setParameter("InstanceRamRole", instanceRamRole);
+}
+
+std::string CreateReplicationJobRequest::getName()const
+{
+	return name_;
+}
+
+void CreateReplicationJobRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+int CreateReplicationJobRequest::getMaxNumberOfImageToKeep()const
+{
+	return maxNumberOfImageToKeep_;
+}
+
+void CreateReplicationJobRequest::setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep)
+{
+	maxNumberOfImageToKeep_ = maxNumberOfImageToKeep;
+	setParameter("MaxNumberOfImageToKeep", std::to_string(maxNumberOfImageToKeep));
+}
+
 std::string CreateReplicationJobRequest::getTargetType()const
 {
 	return targetType_;
@@ -71,28 +241,6 @@ void CreateReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
-int CreateReplicationJobRequest::getFrequency()const
-{
-	return frequency_;
-}
-
-void CreateReplicationJobRequest::setFrequency(int frequency)
-{
-	frequency_ = frequency;
-	setParameter("Frequency", std::to_string(frequency));
-}
-
-std::string CreateReplicationJobRequest::getReplicationParameters()const
-{
-	return replicationParameters_;
-}
-
-void CreateReplicationJobRequest::setReplicationParameters(const std::string& replicationParameters)
-{
-	replicationParameters_ = replicationParameters;
-	setParameter("ReplicationParameters", replicationParameters);
-}
-
 std::string CreateReplicationJobRequest::getRegionId()const
 {
 	return regionId_;
@@ -115,17 +263,6 @@ void CreateReplicationJobRequest::setImageName(const std::string& imageName)
 	setParameter("ImageName", imageName);
 }
 
-int CreateReplicationJobRequest::getSystemDiskSize()const
-{
-	return systemDiskSize_;
-}
-
-void CreateReplicationJobRequest::setSystemDiskSize(int systemDiskSize)
-{
-	systemDiskSize_ = systemDiskSize;
-	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
-}
-
 std::string CreateReplicationJobRequest::getInstanceType()const
 {
 	return instanceType_;
@@ -137,31 +274,26 @@ void CreateReplicationJobRequest::setInstanceType(const std::string& instanceTyp
 	setParameter("InstanceType", instanceType);
 }
 
-std::vector<CreateReplicationJobRequest::Tag> CreateReplicationJobRequest::getTag()const
+std::string CreateReplicationJobRequest::getContainerRepository()const
 {
-	return tag_;
+	return containerRepository_;
 }
 
-void CreateReplicationJobRequest::setTag(const std::vector<Tag>& tag)
+void CreateReplicationJobRequest::setContainerRepository(const std::string& containerRepository)
 {
-	tag_ = tag;
-	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
-		auto tagObj = tag.at(dep1);
-		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
-		setParameter(tagObjStr + ".Value", tagObj.value);
-		setParameter(tagObjStr + ".Key", tagObj.key);
-	}
+	containerRepository_ = containerRepository;
+	setParameter("ContainerRepository", containerRepository);
 }
 
-int CreateReplicationJobRequest::getNetMode()const
+std::string CreateReplicationJobRequest::getContainerTag()const
 {
-	return netMode_;
+	return containerTag_;
 }
 
-void CreateReplicationJobRequest::setNetMode(int netMode)
+void CreateReplicationJobRequest::setContainerTag(const std::string& containerTag)
 {
-	netMode_ = netMode;
-	setParameter("NetMode", std::to_string(netMode));
+	containerTag_ = containerTag;
+	setParameter("ContainerTag", containerTag);
 }
 
 std::string CreateReplicationJobRequest::getSourceId()const
@@ -186,17 +318,6 @@ void CreateReplicationJobRequest::setRunOnce(bool runOnce)
 	setParameter("RunOnce", runOnce ? "true" : "false");
 }
 
-std::string CreateReplicationJobRequest::getLaunchTemplateId()const
-{
-	return launchTemplateId_;
-}
-
-void CreateReplicationJobRequest::setLaunchTemplateId(const std::string& launchTemplateId)
-{
-	launchTemplateId_ = launchTemplateId;
-	setParameter("LaunchTemplateId", launchTemplateId);
-}
-
 std::string CreateReplicationJobRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -208,26 +329,21 @@ void CreateReplicationJobRequest::setResourceOwnerAccount(const std::string& res
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
-std::string CreateReplicationJobRequest::getValidTime()const
-{
-	return validTime_;
-}
-
-void CreateReplicationJobRequest::setValidTime(const std::string& validTime)
-{
-	validTime_ = validTime;
-	setParameter("ValidTime", validTime);
-}
-
-long CreateReplicationJobRequest::getOwnerId()const
+std::vector<CreateReplicationJobRequest::SystemDiskPart> CreateReplicationJobRequest::getSystemDiskPart()const
 {
-	return ownerId_;
+	return systemDiskPart_;
 }
 
-void CreateReplicationJobRequest::setOwnerId(long ownerId)
+void CreateReplicationJobRequest::setSystemDiskPart(const std::vector<SystemDiskPart>& systemDiskPart)
 {
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	systemDiskPart_ = systemDiskPart;
+	for(int dep1 = 0; dep1!= systemDiskPart.size(); dep1++) {
+		auto systemDiskPartObj = systemDiskPart.at(dep1);
+		std::string systemDiskPartObjStr = "SystemDiskPart." + std::to_string(dep1 + 1);
+		setParameter(systemDiskPartObjStr + ".SizeBytes", std::to_string(systemDiskPartObj.sizeBytes));
+		setParameter(systemDiskPartObjStr + ".Block", systemDiskPartObj.block ? "true" : "false");
+		setParameter(systemDiskPartObjStr + ".Device", systemDiskPartObj.device);
+	}
 }
 
 std::vector<CreateReplicationJobRequest::DataDisk> CreateReplicationJobRequest::getDataDisk()const
@@ -242,6 +358,13 @@ void CreateReplicationJobRequest::setDataDisk(const std::vector<DataDisk>& dataD
 		auto dataDiskObj = dataDisk.at(dep1);
 		std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1 + 1);
 		setParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size));
+		for(int dep2 = 0; dep2!= dataDiskObj.part.size(); dep2++) {
+			auto partObj = dataDiskObj.part.at(dep2);
+			std::string partObjStr = dataDiskObjStr + "Part." + std::to_string(dep2 + 1);
+			setParameter(partObjStr + ".SizeBytes", std::to_string(partObj.sizeBytes));
+			setParameter(partObjStr + ".Block", partObj.block ? "true" : "false");
+			setParameter(partObjStr + ".Device", partObj.device);
+		}
 		setParameter(dataDiskObjStr + ".Index", std::to_string(dataDiskObj.index));
 	}
 }
@@ -257,39 +380,6 @@ void CreateReplicationJobRequest::setLaunchTemplateVersion(const std::string& la
 	setParameter("LaunchTemplateVersion", launchTemplateVersion);
 }
 
-std::string CreateReplicationJobRequest::getVSwitchId()const
-{
-	return vSwitchId_;
-}
-
-void CreateReplicationJobRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
-}
-
-std::string CreateReplicationJobRequest::getScheduledStartTime()const
-{
-	return scheduledStartTime_;
-}
-
-void CreateReplicationJobRequest::setScheduledStartTime(const std::string& scheduledStartTime)
-{
-	scheduledStartTime_ = scheduledStartTime;
-	setParameter("ScheduledStartTime", scheduledStartTime);
-}
-
-std::string CreateReplicationJobRequest::getInstanceId()const
-{
-	return instanceId_;
-}
-
-void CreateReplicationJobRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
-}
-
 std::string CreateReplicationJobRequest::getVpcId()const
 {
 	return vpcId_;
@@ -301,25 +391,3 @@ void CreateReplicationJobRequest::setVpcId(const std::string& vpcId)
 	setParameter("VpcId", vpcId);
 }
 
-std::string CreateReplicationJobRequest::getName()const
-{
-	return name_;
-}
-
-void CreateReplicationJobRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
-}
-
-int CreateReplicationJobRequest::getMaxNumberOfImageToKeep()const
-{
-	return maxNumberOfImageToKeep_;
-}
-
-void CreateReplicationJobRequest::setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep)
-{
-	maxNumberOfImageToKeep_ = maxNumberOfImageToKeep;
-	setParameter("MaxNumberOfImageToKeep", std::to_string(maxNumberOfImageToKeep));
-}
-

smc/src/model/DescribeReplicationJobsResult.cc

@@ -105,28 +105,60 @@ void DescribeReplicationJobsResult::parse(const std::string &payload)
 			replicationJobsObject.launchTemplateId = valueReplicationJobsReplicationJob["LaunchTemplateId"].asString();
 		if(!valueReplicationJobsReplicationJob["LaunchTemplateVersion"].isNull())
 			replicationJobsObject.launchTemplateVersion = valueReplicationJobsReplicationJob["LaunchTemplateVersion"].asString();
-		auto allDataDisksNode = allReplicationJobsNode["DataDisks"]["DataDisk"];
-		for (auto allReplicationJobsNodeDataDisksDataDisk : allDataDisksNode)
+		if(!valueReplicationJobsReplicationJob["InstanceRamRole"].isNull())
+			replicationJobsObject.instanceRamRole = valueReplicationJobsReplicationJob["InstanceRamRole"].asString();
+		if(!valueReplicationJobsReplicationJob["ContainerNamespace"].isNull())
+			replicationJobsObject.containerNamespace = valueReplicationJobsReplicationJob["ContainerNamespace"].asString();
+		if(!valueReplicationJobsReplicationJob["ContainerRepository"].isNull())
+			replicationJobsObject.containerRepository = valueReplicationJobsReplicationJob["ContainerRepository"].asString();
+		if(!valueReplicationJobsReplicationJob["ContainerTag"].isNull())
+			replicationJobsObject.containerTag = valueReplicationJobsReplicationJob["ContainerTag"].asString();
+		auto allSystemDiskPartsNode = valueReplicationJobsReplicationJob["SystemDiskParts"]["SystemDiskPart"];
+		for (auto valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart : allSystemDiskPartsNode)
+		{
+			ReplicationJob::SystemDiskPart systemDiskPartsObject;
+			if(!valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart["Device"].isNull())
+				systemDiskPartsObject.device = valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart["Device"].asString();
+			if(!valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart["SizeBytes"].isNull())
+				systemDiskPartsObject.sizeBytes = std::stol(valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart["SizeBytes"].asString());
+			if(!valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart["Block"].isNull())
+				systemDiskPartsObject.block = valueReplicationJobsReplicationJobSystemDiskPartsSystemDiskPart["Block"].asString() == "true";
+			replicationJobsObject.systemDiskParts.push_back(systemDiskPartsObject);
+		}
+		auto allDataDisksNode = valueReplicationJobsReplicationJob["DataDisks"]["DataDisk"];
+		for (auto valueReplicationJobsReplicationJobDataDisksDataDisk : allDataDisksNode)
 		{
 			ReplicationJob::DataDisk dataDisksObject;
-			if(!allReplicationJobsNodeDataDisksDataDisk["Size"].isNull())
-				dataDisksObject.size = std::stoi(allReplicationJobsNodeDataDisksDataDisk["Size"].asString());
-			if(!allReplicationJobsNodeDataDisksDataDisk["Index"].isNull())
-				dataDisksObject.index = std::stoi(allReplicationJobsNodeDataDisksDataDisk["Index"].asString());
+			if(!valueReplicationJobsReplicationJobDataDisksDataDisk["Size"].isNull())
+				dataDisksObject.size = std::stoi(valueReplicationJobsReplicationJobDataDisksDataDisk["Size"].asString());
+			if(!valueReplicationJobsReplicationJobDataDisksDataDisk["Index"].isNull())
+				dataDisksObject.index = std::stoi(valueReplicationJobsReplicationJobDataDisksDataDisk["Index"].asString());
+			auto allPartsNode = valueReplicationJobsReplicationJobDataDisksDataDisk["Parts"]["Part"];
+			for (auto valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart : allPartsNode)
+			{
+				ReplicationJob::DataDisk::Part partsObject;
+				if(!valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart["Device"].isNull())
+					partsObject.device = valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart["Device"].asString();
+				if(!valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart["SizeBytes"].isNull())
+					partsObject.sizeBytes = std::stol(valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart["SizeBytes"].asString());
+				if(!valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart["Block"].isNull())
+					partsObject.block = valueReplicationJobsReplicationJobDataDisksDataDiskPartsPart["Block"].asString() == "true";
+				dataDisksObject.parts.push_back(partsObject);
+			}
 			replicationJobsObject.dataDisks.push_back(dataDisksObject);
 		}
-		auto allReplicationJobRunsNode = allReplicationJobsNode["ReplicationJobRuns"]["ReplicationJobRun"];
-		for (auto allReplicationJobsNodeReplicationJobRunsReplicationJobRun : allReplicationJobRunsNode)
+		auto allReplicationJobRunsNode = valueReplicationJobsReplicationJob["ReplicationJobRuns"]["ReplicationJobRun"];
+		for (auto valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun : allReplicationJobRunsNode)
 		{
 			ReplicationJob::ReplicationJobRun replicationJobRunsObject;
-			if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["ImageId"].isNull())
-				replicationJobRunsObject.imageId = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["ImageId"].asString();
-			if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["Type"].isNull())
-				replicationJobRunsObject.type = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["Type"].asString();
-			if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["StartTime"].isNull())
-				replicationJobRunsObject.startTime = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["StartTime"].asString();
-			if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["EndTime"].isNull())
-				replicationJobRunsObject.endTime = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["EndTime"].asString();
+			if(!valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["ImageId"].isNull())
+				replicationJobRunsObject.imageId = valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["ImageId"].asString();
+			if(!valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["Type"].isNull())
+				replicationJobRunsObject.type = valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["Type"].asString();
+			if(!valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["StartTime"].isNull())
+				replicationJobRunsObject.startTime = valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["StartTime"].asString();
+			if(!valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["EndTime"].isNull())
+				replicationJobRunsObject.endTime = valueReplicationJobsReplicationJobReplicationJobRunsReplicationJobRun["EndTime"].asString();
 			replicationJobsObject.replicationJobRuns.push_back(replicationJobRunsObject);
 		}
 		replicationJobs_.push_back(replicationJobsObject);

smc/src/model/DescribeSourceServersResult.cc

@@ -75,18 +75,50 @@ void DescribeSourceServersResult::parse(const std::string &payload)
 			sourceServersObject.statusInfo = valueSourceServersSourceServer["StatusInfo"].asString();
 		if(!valueSourceServersSourceServer["HeartbeatRate"].isNull())
 			sourceServersObject.heartbeatRate = std::stoi(valueSourceServersSourceServer["HeartbeatRate"].asString());
-		auto allDataDisksNode = allSourceServersNode["DataDisks"]["DataDisk"];
-		for (auto allSourceServersNodeDataDisksDataDisk : allDataDisksNode)
+		auto allDataDisksNode = valueSourceServersSourceServer["DataDisks"]["DataDisk"];
+		for (auto valueSourceServersSourceServerDataDisksDataDisk : allDataDisksNode)
 		{
 			SourceServer::DataDisk dataDisksObject;
-			if(!allSourceServersNodeDataDisksDataDisk["Index"].isNull())
-				dataDisksObject.index = std::stoi(allSourceServersNodeDataDisksDataDisk["Index"].asString());
-			if(!allSourceServersNodeDataDisksDataDisk["Size"].isNull())
-				dataDisksObject.size = std::stoi(allSourceServersNodeDataDisksDataDisk["Size"].asString());
-			if(!allSourceServersNodeDataDisksDataDisk["Path"].isNull())
-				dataDisksObject.path = allSourceServersNodeDataDisksDataDisk["Path"].asString();
+			if(!valueSourceServersSourceServerDataDisksDataDisk["Index"].isNull())
+				dataDisksObject.index = std::stoi(valueSourceServersSourceServerDataDisksDataDisk["Index"].asString());
+			if(!valueSourceServersSourceServerDataDisksDataDisk["Size"].isNull())
+				dataDisksObject.size = std::stoi(valueSourceServersSourceServerDataDisksDataDisk["Size"].asString());
+			if(!valueSourceServersSourceServerDataDisksDataDisk["Path"].isNull())
+				dataDisksObject.path = valueSourceServersSourceServerDataDisksDataDisk["Path"].asString();
+			auto allPartsNode = valueSourceServersSourceServerDataDisksDataDisk["Parts"]["Part"];
+			for (auto valueSourceServersSourceServerDataDisksDataDiskPartsPart : allPartsNode)
+			{
+				SourceServer::DataDisk::Part partsObject;
+				if(!valueSourceServersSourceServerDataDisksDataDiskPartsPart["Path"].isNull())
+					partsObject.path = valueSourceServersSourceServerDataDisksDataDiskPartsPart["Path"].asString();
+				if(!valueSourceServersSourceServerDataDisksDataDiskPartsPart["Device"].isNull())
+					partsObject.device = valueSourceServersSourceServerDataDisksDataDiskPartsPart["Device"].asString();
+				if(!valueSourceServersSourceServerDataDisksDataDiskPartsPart["SizeBytes"].isNull())
+					partsObject.sizeBytes = std::stol(valueSourceServersSourceServerDataDisksDataDiskPartsPart["SizeBytes"].asString());
+				if(!valueSourceServersSourceServerDataDisksDataDiskPartsPart["Need"].isNull())
+					partsObject.need = valueSourceServersSourceServerDataDisksDataDiskPartsPart["Need"].asString() == "true";
+				if(!valueSourceServersSourceServerDataDisksDataDiskPartsPart["CanBlock"].isNull())
+					partsObject.canBlock = valueSourceServersSourceServerDataDisksDataDiskPartsPart["CanBlock"].asString() == "true";
+				dataDisksObject.parts.push_back(partsObject);
+			}
 			sourceServersObject.dataDisks.push_back(dataDisksObject);
 		}
+		auto allSystemDiskPartsNode = valueSourceServersSourceServer["SystemDiskParts"]["SystemDiskPart"];
+		for (auto valueSourceServersSourceServerSystemDiskPartsSystemDiskPart : allSystemDiskPartsNode)
+		{
+			SourceServer::SystemDiskPart systemDiskPartsObject;
+			if(!valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["Path"].isNull())
+				systemDiskPartsObject.path = valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["Path"].asString();
+			if(!valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["Device"].isNull())
+				systemDiskPartsObject.device = valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["Device"].asString();
+			if(!valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["SizeBytes"].isNull())
+				systemDiskPartsObject.sizeBytes = std::stol(valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["SizeBytes"].asString());
+			if(!valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["Need"].isNull())
+				systemDiskPartsObject.need = valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["Need"].asString() == "true";
+			if(!valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["CanBlock"].isNull())
+				systemDiskPartsObject.canBlock = valueSourceServersSourceServerSystemDiskPartsSystemDiskPart["CanBlock"].asString() == "true";
+			sourceServersObject.systemDiskParts.push_back(systemDiskPartsObject);
+		}
 		sourceServers_.push_back(sourceServersObject);
 	}
 	if(!value["TotalCount"].isNull())

smc/src/model/ModifyReplicationJobAttributeRequest.cc

@@ -115,6 +115,39 @@ void ModifyReplicationJobAttributeRequest::setInstanceType(const std::string& in
 	setParameter("InstanceType", instanceType);
 }
 
+std::string ModifyReplicationJobAttributeRequest::getContainerRepository()const
+{
+	return containerRepository_;
+}
+
+void ModifyReplicationJobAttributeRequest::setContainerRepository(const std::string& containerRepository)
+{
+	containerRepository_ = containerRepository;
+	setParameter("ContainerRepository", containerRepository);
+}
+
+std::string ModifyReplicationJobAttributeRequest::getContainerTag()const
+{
+	return containerTag_;
+}
+
+void ModifyReplicationJobAttributeRequest::setContainerTag(const std::string& containerTag)
+{
+	containerTag_ = containerTag;
+	setParameter("ContainerTag", containerTag);
+}
+
+std::string ModifyReplicationJobAttributeRequest::getContainerNamespace()const
+{
+	return containerNamespace_;
+}
+
+void ModifyReplicationJobAttributeRequest::setContainerNamespace(const std::string& containerNamespace)
+{
+	containerNamespace_ = containerNamespace;
+	setParameter("ContainerNamespace", containerNamespace);
+}
+
 std::string ModifyReplicationJobAttributeRequest::getLaunchTemplateId()const
 {
 	return launchTemplateId_;
@@ -137,6 +170,34 @@ void ModifyReplicationJobAttributeRequest::setResourceOwnerAccount(const std::st
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
+std::vector<ModifyReplicationJobAttributeRequest::SystemDiskPart> ModifyReplicationJobAttributeRequest::getSystemDiskPart()const
+{
+	return systemDiskPart_;
+}
+
+void ModifyReplicationJobAttributeRequest::setSystemDiskPart(const std::vector<SystemDiskPart>& systemDiskPart)
+{
+	systemDiskPart_ = systemDiskPart;
+	for(int dep1 = 0; dep1!= systemDiskPart.size(); dep1++) {
+		auto systemDiskPartObj = systemDiskPart.at(dep1);
+		std::string systemDiskPartObjStr = "SystemDiskPart." + std::to_string(dep1 + 1);
+		setParameter(systemDiskPartObjStr + ".SizeBytes", std::to_string(systemDiskPartObj.sizeBytes));
+		setParameter(systemDiskPartObjStr + ".Block", systemDiskPartObj.block ? "true" : "false");
+		setParameter(systemDiskPartObjStr + ".Device", systemDiskPartObj.device);
+	}
+}
+
+std::string ModifyReplicationJobAttributeRequest::getValidTime()const
+{
+	return validTime_;
+}
+
+void ModifyReplicationJobAttributeRequest::setValidTime(const std::string& validTime)
+{
+	validTime_ = validTime;
+	setParameter("ValidTime", validTime);
+}
+
 long ModifyReplicationJobAttributeRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -160,6 +221,13 @@ void ModifyReplicationJobAttributeRequest::setDataDisk(const std::vector<DataDis
 		auto dataDiskObj = dataDisk.at(dep1);
 		std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1 + 1);
 		setParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size));
+		for(int dep2 = 0; dep2!= dataDiskObj.part.size(); dep2++) {
+			auto partObj = dataDiskObj.part.at(dep2);
+			std::string partObjStr = dataDiskObjStr + "Part." + std::to_string(dep2 + 1);
+			setParameter(partObjStr + ".SizeBytes", std::to_string(partObj.sizeBytes));
+			setParameter(partObjStr + ".Block", partObj.block ? "true" : "false");
+			setParameter(partObjStr + ".Device", partObj.device);
+		}
 		setParameter(dataDiskObjStr + ".Index", std::to_string(dataDiskObj.index));
 	}
 }
@@ -197,6 +265,17 @@ void ModifyReplicationJobAttributeRequest::setInstanceId(const std::string& inst
 	setParameter("InstanceId", instanceId);
 }
 
+std::string ModifyReplicationJobAttributeRequest::getInstanceRamRole()const
+{
+	return instanceRamRole_;
+}
+
+void ModifyReplicationJobAttributeRequest::setInstanceRamRole(const std::string& instanceRamRole)
+{
+	instanceRamRole_ = instanceRamRole;
+	setParameter("InstanceRamRole", instanceRamRole);
+}
+
 std::string ModifyReplicationJobAttributeRequest::getName()const
 {
 	return name_;