Generated 2019-06-01 for smc.

CHANGELOG

@@ -1,3 +1,16 @@
+2020-11-12 Version: patch
+- Generated 2019-06-01 for `smc`.
+
+2020-11-12 Version: patch
+- Update new version.
+
+2020-11-12 Version: patch
+- Support DescribeDBClusterTDE.
+- Support ModifyDBClusterTDE.
+
+2020-11-12 Version: patch
+- Supported Open Api.
+
 2020-11-12 Version: patch
 - Support OpenAPI.
 

polardb/CMakeLists.txt

@@ -83,6 +83,8 @@ set(polardb_public_header_model
 	include/alibabacloud/polardb/model/DescribeDBClusterPerformanceResult.h
 	include/alibabacloud/polardb/model/DescribeDBClusterSSLRequest.h
 	include/alibabacloud/polardb/model/DescribeDBClusterSSLResult.h
+	include/alibabacloud/polardb/model/DescribeDBClusterTDERequest.h
+	include/alibabacloud/polardb/model/DescribeDBClusterTDEResult.h
 	include/alibabacloud/polardb/model/DescribeDBClustersRequest.h
 	include/alibabacloud/polardb/model/DescribeDBClustersResult.h
 	include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsRequest.h
@@ -137,6 +139,8 @@ set(polardb_public_header_model
 	include/alibabacloud/polardb/model/ModifyDBClusterParametersResult.h
 	include/alibabacloud/polardb/model/ModifyDBClusterSSLRequest.h
 	include/alibabacloud/polardb/model/ModifyDBClusterSSLResult.h
+	include/alibabacloud/polardb/model/ModifyDBClusterTDERequest.h
+	include/alibabacloud/polardb/model/ModifyDBClusterTDEResult.h
 	include/alibabacloud/polardb/model/ModifyDBDescriptionRequest.h
 	include/alibabacloud/polardb/model/ModifyDBDescriptionResult.h
 	include/alibabacloud/polardb/model/ModifyDBEndpointAddressRequest.h
@@ -222,6 +226,8 @@ set(polardb_src
 	src/model/DescribeDBClusterPerformanceResult.cc
 	src/model/DescribeDBClusterSSLRequest.cc
 	src/model/DescribeDBClusterSSLResult.cc
+	src/model/DescribeDBClusterTDERequest.cc
+	src/model/DescribeDBClusterTDEResult.cc
 	src/model/DescribeDBClustersRequest.cc
 	src/model/DescribeDBClustersResult.cc
 	src/model/DescribeDBClustersWithBackupsRequest.cc
@@ -276,6 +282,8 @@ set(polardb_src
 	src/model/ModifyDBClusterParametersResult.cc
 	src/model/ModifyDBClusterSSLRequest.cc
 	src/model/ModifyDBClusterSSLResult.cc
+	src/model/ModifyDBClusterTDERequest.cc
+	src/model/ModifyDBClusterTDEResult.cc
 	src/model/ModifyDBDescriptionRequest.cc
 	src/model/ModifyDBDescriptionResult.cc
 	src/model/ModifyDBEndpointAddressRequest.cc

polardb/include/alibabacloud/polardb/PolardbClient.h

@@ -84,6 +84,8 @@
 #include "model/DescribeDBClusterPerformanceResult.h"
 #include "model/DescribeDBClusterSSLRequest.h"
 #include "model/DescribeDBClusterSSLResult.h"
+#include "model/DescribeDBClusterTDERequest.h"
+#include "model/DescribeDBClusterTDEResult.h"
 #include "model/DescribeDBClustersRequest.h"
 #include "model/DescribeDBClustersResult.h"
 #include "model/DescribeDBClustersWithBackupsRequest.h"
@@ -138,6 +140,8 @@
 #include "model/ModifyDBClusterParametersResult.h"
 #include "model/ModifyDBClusterSSLRequest.h"
 #include "model/ModifyDBClusterSSLResult.h"
+#include "model/ModifyDBClusterTDERequest.h"
+#include "model/ModifyDBClusterTDEResult.h"
 #include "model/ModifyDBDescriptionRequest.h"
 #include "model/ModifyDBDescriptionResult.h"
 #include "model/ModifyDBEndpointAddressRequest.h"
@@ -260,6 +264,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDBClusterSSLResult> DescribeDBClusterSSLOutcome;
 			typedef std::future<DescribeDBClusterSSLOutcome> DescribeDBClusterSSLOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeDBClusterSSLRequest&, const DescribeDBClusterSSLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterSSLAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterTDEResult> DescribeDBClusterTDEOutcome;
+			typedef std::future<DescribeDBClusterTDEOutcome> DescribeDBClusterTDEOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::DescribeDBClusterTDERequest&, const DescribeDBClusterTDEOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterTDEAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDBClustersResult> DescribeDBClustersOutcome;
 			typedef std::future<DescribeDBClustersOutcome> DescribeDBClustersOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeDBClustersRequest&, const DescribeDBClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersAsyncHandler;
@@ -341,6 +348,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyDBClusterSSLResult> ModifyDBClusterSSLOutcome;
 			typedef std::future<ModifyDBClusterSSLOutcome> ModifyDBClusterSSLOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::ModifyDBClusterSSLRequest&, const ModifyDBClusterSSLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterSSLAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterTDEResult> ModifyDBClusterTDEOutcome;
+			typedef std::future<ModifyDBClusterTDEOutcome> ModifyDBClusterTDEOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::ModifyDBClusterTDERequest&, const ModifyDBClusterTDEOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterTDEAsyncHandler;
 			typedef Outcome<Error, Model::ModifyDBDescriptionResult> ModifyDBDescriptionOutcome;
 			typedef std::future<ModifyDBDescriptionOutcome> ModifyDBDescriptionOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::ModifyDBDescriptionRequest&, const ModifyDBDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBDescriptionAsyncHandler;
@@ -469,6 +479,9 @@ namespace AlibabaCloud
 			DescribeDBClusterSSLOutcome describeDBClusterSSL(const Model::DescribeDBClusterSSLRequest &request)const;
 			void describeDBClusterSSLAsync(const Model::DescribeDBClusterSSLRequest& request, const DescribeDBClusterSSLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBClusterSSLOutcomeCallable describeDBClusterSSLCallable(const Model::DescribeDBClusterSSLRequest& request) const;
+			DescribeDBClusterTDEOutcome describeDBClusterTDE(const Model::DescribeDBClusterTDERequest &request)const;
+			void describeDBClusterTDEAsync(const Model::DescribeDBClusterTDERequest& request, const DescribeDBClusterTDEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterTDEOutcomeCallable describeDBClusterTDECallable(const Model::DescribeDBClusterTDERequest& request) const;
 			DescribeDBClustersOutcome describeDBClusters(const Model::DescribeDBClustersRequest &request)const;
 			void describeDBClustersAsync(const Model::DescribeDBClustersRequest& request, const DescribeDBClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBClustersOutcomeCallable describeDBClustersCallable(const Model::DescribeDBClustersRequest& request) const;
@@ -550,6 +563,9 @@ namespace AlibabaCloud
 			ModifyDBClusterSSLOutcome modifyDBClusterSSL(const Model::ModifyDBClusterSSLRequest &request)const;
 			void modifyDBClusterSSLAsync(const Model::ModifyDBClusterSSLRequest& request, const ModifyDBClusterSSLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDBClusterSSLOutcomeCallable modifyDBClusterSSLCallable(const Model::ModifyDBClusterSSLRequest& request) const;
+			ModifyDBClusterTDEOutcome modifyDBClusterTDE(const Model::ModifyDBClusterTDERequest &request)const;
+			void modifyDBClusterTDEAsync(const Model::ModifyDBClusterTDERequest& request, const ModifyDBClusterTDEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterTDEOutcomeCallable modifyDBClusterTDECallable(const Model::ModifyDBClusterTDERequest& request) const;
 			ModifyDBDescriptionOutcome modifyDBDescription(const Model::ModifyDBDescriptionRequest &request)const;
 			void modifyDBDescriptionAsync(const Model::ModifyDBDescriptionRequest& request, const ModifyDBDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDBDescriptionOutcomeCallable modifyDBDescriptionCallable(const Model::ModifyDBDescriptionRequest& request) const;

polardb/include/alibabacloud/polardb/model/DescribeDBClusterTDERequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERTDEREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERTDEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeDBClusterTDERequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDBClusterTDERequest();
+				~DescribeDBClusterTDERequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getDBClusterId()const;
+				void setDBClusterId(const std::string& dBClusterId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string resourceOwnerAccount_;
+				std::string dBClusterId_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERTDEREQUEST_H_

polardb/include/alibabacloud/polardb/model/DescribeDBClusterTDEResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERTDERESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERTDERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeDBClusterTDEResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDBClusterTDEResult();
+				explicit DescribeDBClusterTDEResult(const std::string &payload);
+				~DescribeDBClusterTDEResult();
+				std::string getTDEStatus()const;
+				std::string getDBClusterId()const;
+				std::string getEncryptionKey()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string tDEStatus_;
+				std::string dBClusterId_;
+				std::string encryptionKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERTDERESULT_H_

polardb/include/alibabacloud/polardb/model/ModifyDBClusterTDERequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_MODIFYDBCLUSTERTDEREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_MODIFYDBCLUSTERTDEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT ModifyDBClusterTDERequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyDBClusterTDERequest();
+				~ModifyDBClusterTDERequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getDBClusterId()const;
+				void setDBClusterId(const std::string& dBClusterId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getEncryptionKey()const;
+				void setEncryptionKey(const std::string& encryptionKey);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getRoleArn()const;
+				void setRoleArn(const std::string& roleArn);
+				std::string getTDEStatus()const;
+				void setTDEStatus(const std::string& tDEStatus);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string resourceOwnerAccount_;
+				std::string dBClusterId_;
+				std::string ownerAccount_;
+				std::string encryptionKey_;
+				long ownerId_;
+				std::string roleArn_;
+				std::string tDEStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_MODIFYDBCLUSTERTDEREQUEST_H_

polardb/include/alibabacloud/polardb/model/ModifyDBClusterTDEResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_MODIFYDBCLUSTERTDERESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_MODIFYDBCLUSTERTDERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT ModifyDBClusterTDEResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyDBClusterTDEResult();
+				explicit ModifyDBClusterTDEResult(const std::string &payload);
+				~ModifyDBClusterTDEResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_MODIFYDBCLUSTERTDERESULT_H_

polardb/src/PolardbClient.cc

@@ -1167,6 +1167,42 @@ PolardbClient::DescribeDBClusterSSLOutcomeCallable PolardbClient::describeDBClus
 	return task->get_future();
 }
 
+PolardbClient::DescribeDBClusterTDEOutcome PolardbClient::describeDBClusterTDE(const DescribeDBClusterTDERequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBClusterTDEOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBClusterTDEOutcome(DescribeDBClusterTDEResult(outcome.result()));
+	else
+		return DescribeDBClusterTDEOutcome(outcome.error());
+}
+
+void PolardbClient::describeDBClusterTDEAsync(const DescribeDBClusterTDERequest& request, const DescribeDBClusterTDEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBClusterTDE(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::DescribeDBClusterTDEOutcomeCallable PolardbClient::describeDBClusterTDECallable(const DescribeDBClusterTDERequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBClusterTDEOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBClusterTDE(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::DescribeDBClustersOutcome PolardbClient::describeDBClusters(const DescribeDBClustersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2139,6 +2175,42 @@ PolardbClient::ModifyDBClusterSSLOutcomeCallable PolardbClient::modifyDBClusterS
 	return task->get_future();
 }
 
+PolardbClient::ModifyDBClusterTDEOutcome PolardbClient::modifyDBClusterTDE(const ModifyDBClusterTDERequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDBClusterTDEOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDBClusterTDEOutcome(ModifyDBClusterTDEResult(outcome.result()));
+	else
+		return ModifyDBClusterTDEOutcome(outcome.error());
+}
+
+void PolardbClient::modifyDBClusterTDEAsync(const ModifyDBClusterTDERequest& request, const ModifyDBClusterTDEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDBClusterTDE(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::ModifyDBClusterTDEOutcomeCallable PolardbClient::modifyDBClusterTDECallable(const ModifyDBClusterTDERequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDBClusterTDEOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDBClusterTDE(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::ModifyDBDescriptionOutcome PolardbClient::modifyDBDescription(const ModifyDBDescriptionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

polardb/src/model/DescribeAccountsResult.cc

@@ -57,14 +57,14 @@ void DescribeAccountsResult::parse(const std::string &payload)
 			accountsObject.privilegeExceeded = valueAccountsDBAccount["PrivilegeExceeded"].asString();
 		if(!valueAccountsDBAccount["AccountPasswordValidTime"].isNull())
 			accountsObject.accountPasswordValidTime = valueAccountsDBAccount["AccountPasswordValidTime"].asString();
-		auto allDatabasePrivilegesNode = allAccountsNode["DatabasePrivileges"]["DatabasePrivilege"];
-		for (auto allAccountsNodeDatabasePrivilegesDatabasePrivilege : allDatabasePrivilegesNode)
+		auto allDatabasePrivilegesNode = valueAccountsDBAccount["DatabasePrivileges"]["DatabasePrivilege"];
+		for (auto valueAccountsDBAccountDatabasePrivilegesDatabasePrivilege : allDatabasePrivilegesNode)
 		{
 			DBAccount::DatabasePrivilege databasePrivilegesObject;
-			if(!allAccountsNodeDatabasePrivilegesDatabasePrivilege["DBName"].isNull())
-				databasePrivilegesObject.dBName = allAccountsNodeDatabasePrivilegesDatabasePrivilege["DBName"].asString();
-			if(!allAccountsNodeDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].isNull())
-				databasePrivilegesObject.accountPrivilege = allAccountsNodeDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].asString();
+			if(!valueAccountsDBAccountDatabasePrivilegesDatabasePrivilege["DBName"].isNull())
+				databasePrivilegesObject.dBName = valueAccountsDBAccountDatabasePrivilegesDatabasePrivilege["DBName"].asString();
+			if(!valueAccountsDBAccountDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].isNull())
+				databasePrivilegesObject.accountPrivilege = valueAccountsDBAccountDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].asString();
 			accountsObject.databasePrivileges.push_back(databasePrivilegesObject);
 		}
 		accounts_.push_back(accountsObject);

polardb/src/model/DescribeDBClusterAvailableResourcesResult.cc

@@ -47,20 +47,20 @@ void DescribeDBClusterAvailableResourcesResult::parse(const std::string &payload
 			availableZonesObject.regionId = valueAvailableZonesAvailableZone["RegionId"].asString();
 		if(!valueAvailableZonesAvailableZone["ZoneId"].isNull())
 			availableZonesObject.zoneId = valueAvailableZonesAvailableZone["ZoneId"].asString();
-		auto allSupportedEnginesNode = allAvailableZonesNode["SupportedEngines"]["SupportedEngine"];
-		for (auto allAvailableZonesNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
+		auto allSupportedEnginesNode = valueAvailableZonesAvailableZone["SupportedEngines"]["SupportedEngine"];
+		for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine : allSupportedEnginesNode)
 		{
 			AvailableZone::SupportedEngine supportedEnginesObject;
-			if(!allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].isNull())
-				supportedEnginesObject.engine = allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].asString();
-			auto allAvailableResourcesNode = allSupportedEnginesNode["AvailableResources"]["AvailableResource"];
-			for (auto allSupportedEnginesNodeAvailableResourcesAvailableResource : allAvailableResourcesNode)
+			if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["Engine"].isNull())
+				supportedEnginesObject.engine = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["Engine"].asString();
+			auto allAvailableResourcesNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["AvailableResources"]["AvailableResource"];
+			for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineAvailableResourcesAvailableResource : allAvailableResourcesNode)
 			{
 				AvailableZone::SupportedEngine::AvailableResource availableResourcesObject;
-				if(!allSupportedEnginesNodeAvailableResourcesAvailableResource["DBNodeClass"].isNull())
-					availableResourcesObject.dBNodeClass = allSupportedEnginesNodeAvailableResourcesAvailableResource["DBNodeClass"].asString();
-				if(!allSupportedEnginesNodeAvailableResourcesAvailableResource["Category"].isNull())
-					availableResourcesObject.category = allSupportedEnginesNodeAvailableResourcesAvailableResource["Category"].asString();
+				if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineAvailableResourcesAvailableResource["DBNodeClass"].isNull())
+					availableResourcesObject.dBNodeClass = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineAvailableResourcesAvailableResource["DBNodeClass"].asString();
+				if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineAvailableResourcesAvailableResource["Category"].isNull())
+					availableResourcesObject.category = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineAvailableResourcesAvailableResource["Category"].asString();
 				supportedEnginesObject.availableResources.push_back(availableResourcesObject);
 			}
 			availableZonesObject.supportedEngines.push_back(supportedEnginesObject);

polardb/src/model/DescribeDBClusterEndpointsResult.cc

@@ -59,26 +59,26 @@ void DescribeDBClusterEndpointsResult::parse(const std::string &payload)
 			itemsObject.nodeWithRoles = valueItemsDBEndpoint["NodeWithRoles"].asString();
 		if(!valueItemsDBEndpoint["DBEndpointDescription"].isNull())
 			itemsObject.dBEndpointDescription = valueItemsDBEndpoint["DBEndpointDescription"].asString();
-		auto allAddressItemsNode = allItemsNode["AddressItems"]["Address"];
-		for (auto allItemsNodeAddressItemsAddress : allAddressItemsNode)
+		auto allAddressItemsNode = valueItemsDBEndpoint["AddressItems"]["Address"];
+		for (auto valueItemsDBEndpointAddressItemsAddress : allAddressItemsNode)
 		{
 			DBEndpoint::Address addressItemsObject;
-			if(!allItemsNodeAddressItemsAddress["ConnectionString"].isNull())
-				addressItemsObject.connectionString = allItemsNodeAddressItemsAddress["ConnectionString"].asString();
-			if(!allItemsNodeAddressItemsAddress["IPAddress"].isNull())
-				addressItemsObject.iPAddress = allItemsNodeAddressItemsAddress["IPAddress"].asString();
-			if(!allItemsNodeAddressItemsAddress["NetType"].isNull())
-				addressItemsObject.netType = allItemsNodeAddressItemsAddress["NetType"].asString();
-			if(!allItemsNodeAddressItemsAddress["Port"].isNull())
-				addressItemsObject.port = allItemsNodeAddressItemsAddress["Port"].asString();
-			if(!allItemsNodeAddressItemsAddress["VPCId"].isNull())
-				addressItemsObject.vPCId = allItemsNodeAddressItemsAddress["VPCId"].asString();
-			if(!allItemsNodeAddressItemsAddress["VSwitchId"].isNull())
-				addressItemsObject.vSwitchId = allItemsNodeAddressItemsAddress["VSwitchId"].asString();
-			if(!allItemsNodeAddressItemsAddress["VpcInstanceId"].isNull())
-				addressItemsObject.vpcInstanceId = allItemsNodeAddressItemsAddress["VpcInstanceId"].asString();
-			if(!allItemsNodeAddressItemsAddress["PrivateZoneConnectionString"].isNull())
-				addressItemsObject.privateZoneConnectionString = allItemsNodeAddressItemsAddress["PrivateZoneConnectionString"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["ConnectionString"].isNull())
+				addressItemsObject.connectionString = valueItemsDBEndpointAddressItemsAddress["ConnectionString"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["IPAddress"].isNull())
+				addressItemsObject.iPAddress = valueItemsDBEndpointAddressItemsAddress["IPAddress"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["NetType"].isNull())
+				addressItemsObject.netType = valueItemsDBEndpointAddressItemsAddress["NetType"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["Port"].isNull())
+				addressItemsObject.port = valueItemsDBEndpointAddressItemsAddress["Port"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["VPCId"].isNull())
+				addressItemsObject.vPCId = valueItemsDBEndpointAddressItemsAddress["VPCId"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["VSwitchId"].isNull())
+				addressItemsObject.vSwitchId = valueItemsDBEndpointAddressItemsAddress["VSwitchId"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["VpcInstanceId"].isNull())
+				addressItemsObject.vpcInstanceId = valueItemsDBEndpointAddressItemsAddress["VpcInstanceId"].asString();
+			if(!valueItemsDBEndpointAddressItemsAddress["PrivateZoneConnectionString"].isNull())
+				addressItemsObject.privateZoneConnectionString = valueItemsDBEndpointAddressItemsAddress["PrivateZoneConnectionString"].asString();
 			itemsObject.addressItems.push_back(addressItemsObject);
 		}
 		items_.push_back(itemsObject);

polardb/src/model/DescribeDBClusterMigrationResult.cc

@@ -47,22 +47,22 @@ void DescribeDBClusterMigrationResult::parse(const std::string &payload)
 			dBClusterEndpointListObject.dBEndpointId = valueDBClusterEndpointListDBClusterEndpoint["DBEndpointId"].asString();
 		if(!valueDBClusterEndpointListDBClusterEndpoint["EndpointType"].isNull())
 			dBClusterEndpointListObject.endpointType = valueDBClusterEndpointListDBClusterEndpoint["EndpointType"].asString();
-		auto allAddressItemsNode = allDBClusterEndpointListNode["AddressItems"]["Address"];
-		for (auto allDBClusterEndpointListNodeAddressItemsAddress : allAddressItemsNode)
+		auto allAddressItemsNode = valueDBClusterEndpointListDBClusterEndpoint["AddressItems"]["Address"];
+		for (auto valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress : allAddressItemsNode)
 		{
 			DBClusterEndpoint::Address addressItemsObject;
-			if(!allDBClusterEndpointListNodeAddressItemsAddress["ConnectionString"].isNull())
-				addressItemsObject.connectionString = allDBClusterEndpointListNodeAddressItemsAddress["ConnectionString"].asString();
-			if(!allDBClusterEndpointListNodeAddressItemsAddress["IPAddress"].isNull())
-				addressItemsObject.iPAddress = allDBClusterEndpointListNodeAddressItemsAddress["IPAddress"].asString();
-			if(!allDBClusterEndpointListNodeAddressItemsAddress["NetType"].isNull())
-				addressItemsObject.netType = allDBClusterEndpointListNodeAddressItemsAddress["NetType"].asString();
-			if(!allDBClusterEndpointListNodeAddressItemsAddress["Port"].isNull())
-				addressItemsObject.port = allDBClusterEndpointListNodeAddressItemsAddress["Port"].asString();
-			if(!allDBClusterEndpointListNodeAddressItemsAddress["VPCId"].isNull())
-				addressItemsObject.vPCId = allDBClusterEndpointListNodeAddressItemsAddress["VPCId"].asString();
-			if(!allDBClusterEndpointListNodeAddressItemsAddress["VSwitchId"].isNull())
-				addressItemsObject.vSwitchId = allDBClusterEndpointListNodeAddressItemsAddress["VSwitchId"].asString();
+			if(!valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["ConnectionString"].isNull())
+				addressItemsObject.connectionString = valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["ConnectionString"].asString();
+			if(!valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["IPAddress"].isNull())
+				addressItemsObject.iPAddress = valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["IPAddress"].asString();
+			if(!valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["NetType"].isNull())
+				addressItemsObject.netType = valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["NetType"].asString();
+			if(!valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["Port"].isNull())
+				addressItemsObject.port = valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["Port"].asString();
+			if(!valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["VPCId"].isNull())
+				addressItemsObject.vPCId = valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["VPCId"].asString();
+			if(!valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["VSwitchId"].isNull())
+				addressItemsObject.vSwitchId = valueDBClusterEndpointListDBClusterEndpointAddressItemsAddress["VSwitchId"].asString();
 			dBClusterEndpointListObject.addressItems.push_back(addressItemsObject);
 		}
 		dBClusterEndpointList_.push_back(dBClusterEndpointListObject);
@@ -75,22 +75,22 @@ void DescribeDBClusterMigrationResult::parse(const std::string &payload)
 			rdsEndpointListObject.dBEndpointId = valueRdsEndpointListRdsEndpoint["DBEndpointId"].asString();
 		if(!valueRdsEndpointListRdsEndpoint["EndpointType"].isNull())
 			rdsEndpointListObject.endpointType = valueRdsEndpointListRdsEndpoint["EndpointType"].asString();
-		auto allAddressItems1Node = allRdsEndpointListNode["AddressItems"]["Address"];
-		for (auto allRdsEndpointListNodeAddressItemsAddress : allAddressItems1Node)
+		auto allAddressItems1Node = valueRdsEndpointListRdsEndpoint["AddressItems"]["Address"];
+		for (auto valueRdsEndpointListRdsEndpointAddressItemsAddress : allAddressItems1Node)
 		{
 			RdsEndpoint::Address2 addressItems1Object;
-			if(!allRdsEndpointListNodeAddressItemsAddress["ConnectionString"].isNull())
-				addressItems1Object.connectionString = allRdsEndpointListNodeAddressItemsAddress["ConnectionString"].asString();
-			if(!allRdsEndpointListNodeAddressItemsAddress["IPAddress"].isNull())
-				addressItems1Object.iPAddress = allRdsEndpointListNodeAddressItemsAddress["IPAddress"].asString();
-			if(!allRdsEndpointListNodeAddressItemsAddress["NetType"].isNull())
-				addressItems1Object.netType = allRdsEndpointListNodeAddressItemsAddress["NetType"].asString();
-			if(!allRdsEndpointListNodeAddressItemsAddress["Port"].isNull())
-				addressItems1Object.port = allRdsEndpointListNodeAddressItemsAddress["Port"].asString();
-			if(!allRdsEndpointListNodeAddressItemsAddress["VPCId"].isNull())
-				addressItems1Object.vPCId = allRdsEndpointListNodeAddressItemsAddress["VPCId"].asString();
-			if(!allRdsEndpointListNodeAddressItemsAddress["VSwitchId"].isNull())
-				addressItems1Object.vSwitchId = allRdsEndpointListNodeAddressItemsAddress["VSwitchId"].asString();
+			if(!valueRdsEndpointListRdsEndpointAddressItemsAddress["ConnectionString"].isNull())
+				addressItems1Object.connectionString = valueRdsEndpointListRdsEndpointAddressItemsAddress["ConnectionString"].asString();
+			if(!valueRdsEndpointListRdsEndpointAddressItemsAddress["IPAddress"].isNull())
+				addressItems1Object.iPAddress = valueRdsEndpointListRdsEndpointAddressItemsAddress["IPAddress"].asString();
+			if(!valueRdsEndpointListRdsEndpointAddressItemsAddress["NetType"].isNull())
+				addressItems1Object.netType = valueRdsEndpointListRdsEndpointAddressItemsAddress["NetType"].asString();
+			if(!valueRdsEndpointListRdsEndpointAddressItemsAddress["Port"].isNull())
+				addressItems1Object.port = valueRdsEndpointListRdsEndpointAddressItemsAddress["Port"].asString();
+			if(!valueRdsEndpointListRdsEndpointAddressItemsAddress["VPCId"].isNull())
+				addressItems1Object.vPCId = valueRdsEndpointListRdsEndpointAddressItemsAddress["VPCId"].asString();
+			if(!valueRdsEndpointListRdsEndpointAddressItemsAddress["VSwitchId"].isNull())
+				addressItems1Object.vSwitchId = valueRdsEndpointListRdsEndpointAddressItemsAddress["VSwitchId"].asString();
 			rdsEndpointListObject.addressItems1.push_back(addressItems1Object);
 		}
 		rdsEndpointList_.push_back(rdsEndpointListObject);

polardb/src/model/DescribeDBClusterPerformanceResult.cc

@@ -49,14 +49,14 @@ void DescribeDBClusterPerformanceResult::parse(const std::string &payload)
 			performanceKeysObject.measurement = valuePerformanceKeysPerformanceItem["Measurement"].asString();
 		if(!valuePerformanceKeysPerformanceItem["MetricName"].isNull())
 			performanceKeysObject.metricName = valuePerformanceKeysPerformanceItem["MetricName"].asString();
-		auto allPointsNode = allPerformanceKeysNode["Points"]["PerformanceItemValue"];
-		for (auto allPerformanceKeysNodePointsPerformanceItemValue : allPointsNode)
+		auto allPointsNode = valuePerformanceKeysPerformanceItem["Points"]["PerformanceItemValue"];
+		for (auto valuePerformanceKeysPerformanceItemPointsPerformanceItemValue : allPointsNode)
 		{
 			PerformanceItem::PerformanceItemValue pointsObject;
-			if(!allPerformanceKeysNodePointsPerformanceItemValue["Value"].isNull())
-				pointsObject.value = allPerformanceKeysNodePointsPerformanceItemValue["Value"].asString();
-			if(!allPerformanceKeysNodePointsPerformanceItemValue["Timestamp"].isNull())
-				pointsObject.timestamp = std::stol(allPerformanceKeysNodePointsPerformanceItemValue["Timestamp"].asString());
+			if(!valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Value"].isNull())
+				pointsObject.value = valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Value"].asString();
+			if(!valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Timestamp"].isNull())
+				pointsObject.timestamp = std::stol(valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Timestamp"].asString());
 			performanceKeysObject.points.push_back(pointsObject);
 		}
 		performanceKeys_.push_back(performanceKeysObject);

polardb/src/model/DescribeDBClusterTDERequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/DescribeDBClusterTDERequest.h>
+
+using AlibabaCloud::Polardb::Model::DescribeDBClusterTDERequest;
+
+DescribeDBClusterTDERequest::DescribeDBClusterTDERequest() :
+	RpcServiceRequest("polardb", "2017-08-01", "DescribeDBClusterTDE")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBClusterTDERequest::~DescribeDBClusterTDERequest()
+{}
+
+long DescribeDBClusterTDERequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDBClusterTDERequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBClusterTDERequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDBClusterTDERequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDBClusterTDERequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDBClusterTDERequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDBClusterTDERequest::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
+void DescribeDBClusterTDERequest::setDBClusterId(const std::string& dBClusterId)
+{
+	dBClusterId_ = dBClusterId;
+	setParameter("DBClusterId", dBClusterId);
+}
+
+std::string DescribeDBClusterTDERequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDBClusterTDERequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeDBClusterTDERequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDBClusterTDERequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

polardb/src/model/DescribeDBClusterTDEResult.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/DescribeDBClusterTDEResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardb;
+using namespace AlibabaCloud::Polardb::Model;
+
+DescribeDBClusterTDEResult::DescribeDBClusterTDEResult() :
+	ServiceResult()
+{}
+
+DescribeDBClusterTDEResult::DescribeDBClusterTDEResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBClusterTDEResult::~DescribeDBClusterTDEResult()
+{}
+
+void DescribeDBClusterTDEResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DBClusterId"].isNull())
+		dBClusterId_ = value["DBClusterId"].asString();
+	if(!value["TDEStatus"].isNull())
+		tDEStatus_ = value["TDEStatus"].asString();
+	if(!value["EncryptionKey"].isNull())
+		encryptionKey_ = value["EncryptionKey"].asString();
+
+}
+
+std::string DescribeDBClusterTDEResult::getTDEStatus()const
+{
+	return tDEStatus_;
+}
+
+std::string DescribeDBClusterTDEResult::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
+std::string DescribeDBClusterTDEResult::getEncryptionKey()const
+{
+	return encryptionKey_;
+}
+

polardb/src/model/DescribeDBClustersResult.cc

@@ -83,30 +83,30 @@ void DescribeDBClustersResult::parse(const std::string &payload)
 			itemsObject.storageUsed = std::stol(valueItemsDBCluster["StorageUsed"].asString());
 		if(!valueItemsDBCluster["ResourceGroupId"].isNull())
 			itemsObject.resourceGroupId = valueItemsDBCluster["ResourceGroupId"].asString();
-		auto allDBNodesNode = allItemsNode["DBNodes"]["DBNode"];
-		for (auto allItemsNodeDBNodesDBNode : allDBNodesNode)
+		auto allDBNodesNode = valueItemsDBCluster["DBNodes"]["DBNode"];
+		for (auto valueItemsDBClusterDBNodesDBNode : allDBNodesNode)
 		{
 			DBCluster::DBNode dBNodesObject;
-			if(!allItemsNodeDBNodesDBNode["DBNodeId"].isNull())
-				dBNodesObject.dBNodeId = allItemsNodeDBNodesDBNode["DBNodeId"].asString();
-			if(!allItemsNodeDBNodesDBNode["DBNodeClass"].isNull())
-				dBNodesObject.dBNodeClass = allItemsNodeDBNodesDBNode["DBNodeClass"].asString();
-			if(!allItemsNodeDBNodesDBNode["DBNodeRole"].isNull())
-				dBNodesObject.dBNodeRole = allItemsNodeDBNodesDBNode["DBNodeRole"].asString();
-			if(!allItemsNodeDBNodesDBNode["RegionId"].isNull())
-				dBNodesObject.regionId = allItemsNodeDBNodesDBNode["RegionId"].asString();
-			if(!allItemsNodeDBNodesDBNode["ZoneId"].isNull())
-				dBNodesObject.zoneId = allItemsNodeDBNodesDBNode["ZoneId"].asString();
+			if(!valueItemsDBClusterDBNodesDBNode["DBNodeId"].isNull())
+				dBNodesObject.dBNodeId = valueItemsDBClusterDBNodesDBNode["DBNodeId"].asString();
+			if(!valueItemsDBClusterDBNodesDBNode["DBNodeClass"].isNull())
+				dBNodesObject.dBNodeClass = valueItemsDBClusterDBNodesDBNode["DBNodeClass"].asString();
+			if(!valueItemsDBClusterDBNodesDBNode["DBNodeRole"].isNull())
+				dBNodesObject.dBNodeRole = valueItemsDBClusterDBNodesDBNode["DBNodeRole"].asString();
+			if(!valueItemsDBClusterDBNodesDBNode["RegionId"].isNull())
+				dBNodesObject.regionId = valueItemsDBClusterDBNodesDBNode["RegionId"].asString();
+			if(!valueItemsDBClusterDBNodesDBNode["ZoneId"].isNull())
+				dBNodesObject.zoneId = valueItemsDBClusterDBNodesDBNode["ZoneId"].asString();
 			itemsObject.dBNodes.push_back(dBNodesObject);
 		}
-		auto allTagsNode = allItemsNode["Tags"]["Tag"];
-		for (auto allItemsNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueItemsDBCluster["Tags"]["Tag"];
+		for (auto valueItemsDBClusterTagsTag : allTagsNode)
 		{
 			DBCluster::Tag tagsObject;
-			if(!allItemsNodeTagsTag["Key"].isNull())
-				tagsObject.key = allItemsNodeTagsTag["Key"].asString();
-			if(!allItemsNodeTagsTag["Value"].isNull())
-				tagsObject.value = allItemsNodeTagsTag["Value"].asString();
+			if(!valueItemsDBClusterTagsTag["Key"].isNull())
+				tagsObject.key = valueItemsDBClusterTagsTag["Key"].asString();
+			if(!valueItemsDBClusterTagsTag["Value"].isNull())
+				tagsObject.value = valueItemsDBClusterTagsTag["Value"].asString();
 			itemsObject.tags.push_back(tagsObject);
 		}
 		items_.push_back(itemsObject);

polardb/src/model/DescribeDBNodePerformanceResult.cc

@@ -47,14 +47,14 @@ void DescribeDBNodePerformanceResult::parse(const std::string &payload)
 			performanceKeysObject.metricName = valuePerformanceKeysPerformanceItem["MetricName"].asString();
 		if(!valuePerformanceKeysPerformanceItem["Measurement"].isNull())
 			performanceKeysObject.measurement = valuePerformanceKeysPerformanceItem["Measurement"].asString();
-		auto allPointsNode = allPerformanceKeysNode["Points"]["PerformanceItemValue"];
-		for (auto allPerformanceKeysNodePointsPerformanceItemValue : allPointsNode)
+		auto allPointsNode = valuePerformanceKeysPerformanceItem["Points"]["PerformanceItemValue"];
+		for (auto valuePerformanceKeysPerformanceItemPointsPerformanceItemValue : allPointsNode)
 		{
 			PerformanceItem::PerformanceItemValue pointsObject;
-			if(!allPerformanceKeysNodePointsPerformanceItemValue["Value"].isNull())
-				pointsObject.value = allPerformanceKeysNodePointsPerformanceItemValue["Value"].asString();
-			if(!allPerformanceKeysNodePointsPerformanceItemValue["Timestamp"].isNull())
-				pointsObject.timestamp = std::stol(allPerformanceKeysNodePointsPerformanceItemValue["Timestamp"].asString());
+			if(!valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Value"].isNull())
+				pointsObject.value = valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Value"].asString();
+			if(!valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Timestamp"].isNull())
+				pointsObject.timestamp = std::stol(valuePerformanceKeysPerformanceItemPointsPerformanceItemValue["Timestamp"].asString());
 			performanceKeysObject.points.push_back(pointsObject);
 		}
 		performanceKeys_.push_back(performanceKeysObject);

polardb/src/model/DescribeDatabasesResult.cc

@@ -53,18 +53,18 @@ void DescribeDatabasesResult::parse(const std::string &payload)
 			databasesObject.characterSetName = valueDatabasesDatabase["CharacterSetName"].asString();
 		if(!valueDatabasesDatabase["Engine"].isNull())
 			databasesObject.engine = valueDatabasesDatabase["Engine"].asString();
-		auto allAccountsNode = allDatabasesNode["Accounts"]["Account"];
-		for (auto allDatabasesNodeAccountsAccount : allAccountsNode)
+		auto allAccountsNode = valueDatabasesDatabase["Accounts"]["Account"];
+		for (auto valueDatabasesDatabaseAccountsAccount : allAccountsNode)
 		{
 			Database::Account accountsObject;
-			if(!allDatabasesNodeAccountsAccount["AccountName"].isNull())
-				accountsObject.accountName = allDatabasesNodeAccountsAccount["AccountName"].asString();
-			if(!allDatabasesNodeAccountsAccount["AccountStatus"].isNull())
-				accountsObject.accountStatus = allDatabasesNodeAccountsAccount["AccountStatus"].asString();
-			if(!allDatabasesNodeAccountsAccount["AccountPrivilege"].isNull())
-				accountsObject.accountPrivilege = allDatabasesNodeAccountsAccount["AccountPrivilege"].asString();
-			if(!allDatabasesNodeAccountsAccount["PrivilegeStatus"].isNull())
-				accountsObject.privilegeStatus = allDatabasesNodeAccountsAccount["PrivilegeStatus"].asString();
+			if(!valueDatabasesDatabaseAccountsAccount["AccountName"].isNull())
+				accountsObject.accountName = valueDatabasesDatabaseAccountsAccount["AccountName"].asString();
+			if(!valueDatabasesDatabaseAccountsAccount["AccountStatus"].isNull())
+				accountsObject.accountStatus = valueDatabasesDatabaseAccountsAccount["AccountStatus"].asString();
+			if(!valueDatabasesDatabaseAccountsAccount["AccountPrivilege"].isNull())
+				accountsObject.accountPrivilege = valueDatabasesDatabaseAccountsAccount["AccountPrivilege"].asString();
+			if(!valueDatabasesDatabaseAccountsAccount["PrivilegeStatus"].isNull())
+				accountsObject.privilegeStatus = valueDatabasesDatabaseAccountsAccount["PrivilegeStatus"].asString();
 			databasesObject.accounts.push_back(accountsObject);
 		}
 		databases_.push_back(databasesObject);

polardb/src/model/DescribeRegionsResult.cc

@@ -45,14 +45,14 @@ void DescribeRegionsResult::parse(const std::string &payload)
 		Region regionsObject;
 		if(!valueRegionsRegion["RegionId"].isNull())
 			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
-		auto allZonesNode = allRegionsNode["Zones"]["Zone"];
-		for (auto allRegionsNodeZonesZone : allZonesNode)
+		auto allZonesNode = valueRegionsRegion["Zones"]["Zone"];
+		for (auto valueRegionsRegionZonesZone : allZonesNode)
 		{
 			Region::Zone zonesObject;
-			if(!allRegionsNodeZonesZone["ZoneId"].isNull())
-				zonesObject.zoneId = allRegionsNodeZonesZone["ZoneId"].asString();
-			if(!allRegionsNodeZonesZone["VpcEnabled"].isNull())
-				zonesObject.vpcEnabled = allRegionsNodeZonesZone["VpcEnabled"].asString() == "true";
+			if(!valueRegionsRegionZonesZone["ZoneId"].isNull())
+				zonesObject.zoneId = valueRegionsRegionZonesZone["ZoneId"].asString();
+			if(!valueRegionsRegionZonesZone["VpcEnabled"].isNull())
+				zonesObject.vpcEnabled = valueRegionsRegionZonesZone["VpcEnabled"].asString() == "true";
 			regionsObject.zones.push_back(zonesObject);
 		}
 		regions_.push_back(regionsObject);

polardb/src/model/ModifyDBClusterTDERequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/ModifyDBClusterTDERequest.h>
+
+using AlibabaCloud::Polardb::Model::ModifyDBClusterTDERequest;
+
+ModifyDBClusterTDERequest::ModifyDBClusterTDERequest() :
+	RpcServiceRequest("polardb", "2017-08-01", "ModifyDBClusterTDE")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyDBClusterTDERequest::~ModifyDBClusterTDERequest()
+{}
+
+long ModifyDBClusterTDERequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyDBClusterTDERequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyDBClusterTDERequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyDBClusterTDERequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyDBClusterTDERequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyDBClusterTDERequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyDBClusterTDERequest::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
+void ModifyDBClusterTDERequest::setDBClusterId(const std::string& dBClusterId)
+{
+	dBClusterId_ = dBClusterId;
+	setParameter("DBClusterId", dBClusterId);
+}
+
+std::string ModifyDBClusterTDERequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyDBClusterTDERequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string ModifyDBClusterTDERequest::getEncryptionKey()const
+{
+	return encryptionKey_;
+}
+
+void ModifyDBClusterTDERequest::setEncryptionKey(const std::string& encryptionKey)
+{
+	encryptionKey_ = encryptionKey;
+	setParameter("EncryptionKey", encryptionKey);
+}
+
+long ModifyDBClusterTDERequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyDBClusterTDERequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyDBClusterTDERequest::getRoleArn()const
+{
+	return roleArn_;
+}
+
+void ModifyDBClusterTDERequest::setRoleArn(const std::string& roleArn)
+{
+	roleArn_ = roleArn;
+	setParameter("RoleArn", roleArn);
+}
+
+std::string ModifyDBClusterTDERequest::getTDEStatus()const
+{
+	return tDEStatus_;
+}
+
+void ModifyDBClusterTDERequest::setTDEStatus(const std::string& tDEStatus)
+{
+	tDEStatus_ = tDEStatus;
+	setParameter("TDEStatus", tDEStatus);
+}
+

polardb/src/model/ModifyDBClusterTDEResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/ModifyDBClusterTDEResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardb;
+using namespace AlibabaCloud::Polardb::Model;
+
+ModifyDBClusterTDEResult::ModifyDBClusterTDEResult() :
+	ServiceResult()
+{}
+
+ModifyDBClusterTDEResult::ModifyDBClusterTDEResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyDBClusterTDEResult::~ModifyDBClusterTDEResult()
+{}
+
+void ModifyDBClusterTDEResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

pvtz/include/alibabacloud/pvtz/model/DescribeRequestGraphRequest.h

@@ -39,10 +39,14 @@ namespace AlibabaCloud
 				void setStartTimestamp(long startTimestamp);
 				long getEndTimestamp()const;
 				void setEndTimestamp(long endTimestamp);
+				std::string getBizType()const;
+				void setBizType(const std::string& bizType);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 				std::string getUserClientIp()const;
 				void setUserClientIp(const std::string& userClientIp);
+				std::string getBizId()const;
+				void setBizId(const std::string& bizId);
 				std::string getZoneId()const;
 				void setZoneId(const std::string& zoneId);
 				std::string getLang()const;
@@ -51,8 +55,10 @@ namespace AlibabaCloud
             private:
 				long startTimestamp_;
 				long endTimestamp_;
+				std::string bizType_;
 				std::string vpcId_;
 				std::string userClientIp_;
+				std::string bizId_;
 				std::string zoneId_;
 				std::string lang_;
 

pvtz/include/alibabacloud/pvtz/model/DescribeStatisticSummaryResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct ZoneRequestTop
 				{
 					std::string zoneName;
+					std::string bizType;
 					long requestCount;
 				};
 				struct VpcRequestTop

pvtz/include/alibabacloud/pvtz/model/DescribeZoneInfoResult.h

@@ -44,34 +44,36 @@ namespace AlibabaCloud
 				DescribeZoneInfoResult();
 				explicit DescribeZoneInfoResult(const std::string &payload);
 				~DescribeZoneInfoResult();
-				std::string getZoneName()const;
 				std::string getZoneId()const;
 				bool getSlaveDns()const;
+				std::string getResourceGroupId()const;
 				std::string getProxyPattern()const;
 				std::string getCreateTime()const;
+				std::string getRemark()const;
+				std::string getZoneName()const;
 				std::string getUpdateTime()const;
 				long getUpdateTimestamp()const;
 				std::vector<Vpc> getBindVpcs()const;
 				int getRecordCount()const;
 				long getCreateTimestamp()const;
 				bool getIsPtr()const;
-				std::string getRemark()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string zoneName_;
 				std::string zoneId_;
 				bool slaveDns_;
+				std::string resourceGroupId_;
 				std::string proxyPattern_;
 				std::string createTime_;
+				std::string remark_;
+				std::string zoneName_;
 				std::string updateTime_;
 				long updateTimestamp_;
 				std::vector<Vpc> bindVpcs_;
 				int recordCount_;
 				long createTimestamp_;
 				bool isPtr_;
-				std::string remark_;
 
 			};
 		}

pvtz/include/alibabacloud/pvtz/model/DescribeZonesResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string zoneName;
 					std::string zoneId;
+					std::string resourceGroupId;
 					std::string proxyPattern;
 					std::string createTime;
 					std::string updateTime;

pvtz/src/model/DescribeRequestGraphRequest.cc

@@ -49,6 +49,17 @@ void DescribeRequestGraphRequest::setEndTimestamp(long endTimestamp)
 	setParameter("EndTimestamp", std::to_string(endTimestamp));
 }
 
+std::string DescribeRequestGraphRequest::getBizType()const
+{
+	return bizType_;
+}
+
+void DescribeRequestGraphRequest::setBizType(const std::string& bizType)
+{
+	bizType_ = bizType;
+	setParameter("BizType", bizType);
+}
+
 std::string DescribeRequestGraphRequest::getVpcId()const
 {
 	return vpcId_;
@@ -71,6 +82,17 @@ void DescribeRequestGraphRequest::setUserClientIp(const std::string& userClientI
 	setParameter("UserClientIp", userClientIp);
 }
 
+std::string DescribeRequestGraphRequest::getBizId()const
+{
+	return bizId_;
+}
+
+void DescribeRequestGraphRequest::setBizId(const std::string& bizId)
+{
+	bizId_ = bizId;
+	setParameter("BizId", bizId);
+}
+
 std::string DescribeRequestGraphRequest::getZoneId()const
 {
 	return zoneId_;

pvtz/src/model/DescribeStatisticSummaryResult.cc

@@ -47,6 +47,8 @@ void DescribeStatisticSummaryResult::parse(const std::string &payload)
 			zoneRequestTopsObject.zoneName = valueZoneRequestTopsZoneRequestTop["ZoneName"].asString();
 		if(!valueZoneRequestTopsZoneRequestTop["RequestCount"].isNull())
 			zoneRequestTopsObject.requestCount = std::stol(valueZoneRequestTopsZoneRequestTop["RequestCount"].asString());
+		if(!valueZoneRequestTopsZoneRequestTop["BizType"].isNull())
+			zoneRequestTopsObject.bizType = valueZoneRequestTopsZoneRequestTop["BizType"].asString();
 		zoneRequestTops_.push_back(zoneRequestTopsObject);
 	}
 	auto allVpcRequestTopsNode = value["VpcRequestTops"]["VpcRequestTop"];

pvtz/src/model/DescribeZoneInfoResult.cc

@@ -75,14 +75,11 @@ void DescribeZoneInfoResult::parse(const std::string &payload)
 		proxyPattern_ = value["ProxyPattern"].asString();
 	if(!value["SlaveDns"].isNull())
 		slaveDns_ = value["SlaveDns"].asString() == "true";
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
 
 }
 
-std::string DescribeZoneInfoResult::getZoneName()const
-{
-	return zoneName_;
-}
-
 std::string DescribeZoneInfoResult::getZoneId()const
 {
 	return zoneId_;
@@ -93,6 +90,11 @@ bool DescribeZoneInfoResult::getSlaveDns()const
 	return slaveDns_;
 }
 
+std::string DescribeZoneInfoResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
 std::string DescribeZoneInfoResult::getProxyPattern()const
 {
 	return proxyPattern_;
@@ -103,6 +105,16 @@ std::string DescribeZoneInfoResult::getCreateTime()const
 	return createTime_;
 }
 
+std::string DescribeZoneInfoResult::getRemark()const
+{
+	return remark_;
+}
+
+std::string DescribeZoneInfoResult::getZoneName()const
+{
+	return zoneName_;
+}
+
 std::string DescribeZoneInfoResult::getUpdateTime()const
 {
 	return updateTime_;
@@ -133,8 +145,3 @@ bool DescribeZoneInfoResult::getIsPtr()const
 	return isPtr_;
 }
 
-std::string DescribeZoneInfoResult::getRemark()const
-{
-	return remark_;
-}
-

pvtz/src/model/DescribeZoneVpcTreeResult.cc

@@ -61,18 +61,18 @@ void DescribeZoneVpcTreeResult::parse(const std::string &payload)
 			zonesObject.updateTimestamp = std::stol(valueZonesZone["UpdateTimestamp"].asString());
 		if(!valueZonesZone["IsPtr"].isNull())
 			zonesObject.isPtr = valueZonesZone["IsPtr"].asString() == "true";
-		auto allVpcsNode = allZonesNode["Vpcs"]["Vpc"];
-		for (auto allZonesNodeVpcsVpc : allVpcsNode)
+		auto allVpcsNode = valueZonesZone["Vpcs"]["Vpc"];
+		for (auto valueZonesZoneVpcsVpc : allVpcsNode)
 		{
 			Zone::Vpc vpcsObject;
-			if(!allZonesNodeVpcsVpc["RegionId"].isNull())
-				vpcsObject.regionId = allZonesNodeVpcsVpc["RegionId"].asString();
-			if(!allZonesNodeVpcsVpc["RegionName"].isNull())
-				vpcsObject.regionName = allZonesNodeVpcsVpc["RegionName"].asString();
-			if(!allZonesNodeVpcsVpc["VpcId"].isNull())
-				vpcsObject.vpcId = allZonesNodeVpcsVpc["VpcId"].asString();
-			if(!allZonesNodeVpcsVpc["VpcName"].isNull())
-				vpcsObject.vpcName = allZonesNodeVpcsVpc["VpcName"].asString();
+			if(!valueZonesZoneVpcsVpc["RegionId"].isNull())
+				vpcsObject.regionId = valueZonesZoneVpcsVpc["RegionId"].asString();
+			if(!valueZonesZoneVpcsVpc["RegionName"].isNull())
+				vpcsObject.regionName = valueZonesZoneVpcsVpc["RegionName"].asString();
+			if(!valueZonesZoneVpcsVpc["VpcId"].isNull())
+				vpcsObject.vpcId = valueZonesZoneVpcsVpc["VpcId"].asString();
+			if(!valueZonesZoneVpcsVpc["VpcName"].isNull())
+				vpcsObject.vpcName = valueZonesZoneVpcsVpc["VpcName"].asString();
 			zonesObject.vpcs.push_back(vpcsObject);
 		}
 		zones_.push_back(zonesObject);

pvtz/src/model/DescribeZonesResult.cc

@@ -63,6 +63,8 @@ void DescribeZonesResult::parse(const std::string &payload)
 			zonesObject.isPtr = valueZonesZone["IsPtr"].asString() == "true";
 		if(!valueZonesZone["ProxyPattern"].isNull())
 			zonesObject.proxyPattern = valueZonesZone["ProxyPattern"].asString();
+		if(!valueZonesZone["ResourceGroupId"].isNull())
+			zonesObject.resourceGroupId = valueZonesZone["ResourceGroupId"].asString();
 		zones_.push_back(zonesObject);
 	}
 	if(!value["TotalItems"].isNull())

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,6 +59,36 @@ namespace AlibabaCloud
 				CreateReplicationJobRequest();
 				~CreateReplicationJobRequest();
 
+				int getFrequency()const;
+				void setFrequency(int frequency);
+				std::string getReplicationParameters()const;
+				void setReplicationParameters(const std::string& replicationParameters);
+				int getSystemDiskSize()const;
+				void setSystemDiskSize(int systemDiskSize);
+				std::vector<Tag> getTag()const;
+				void setTag(const std::vector<Tag>& tag);
+				int getNetMode()const;
+				void setNetMode(int netMode);
+				std::string getContainerNamespace()const;
+				void setContainerNamespace(const std::string& containerNamespace);
+				std::string getLaunchTemplateId()const;
+				void setLaunchTemplateId(const std::string& launchTemplateId);
+				std::string getValidTime()const;
+				void setValidTime(const std::string& validTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				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 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;
@@ -54,78 +97,63 @@ namespace AlibabaCloud
 				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 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 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<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 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 getName()const;
-				void setName(const std::string& name);
-				int getMaxNumberOfImageToKeep()const;
-				void setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep);
 
             private:
+				int frequency_;
+				std::string replicationParameters_;
+				int systemDiskSize_;
+				std::vector<Tag> tag_;
+				int netMode_;
+				std::string containerNamespace_;
+				std::string launchTemplateId_;
+				std::string validTime_;
+				long ownerId_;
+				std::string vSwitchId_;
+				std::string scheduledStartTime_;
+				std::string instanceId_;
+				std::string instanceRamRole_;
+				std::string name_;
+				int maxNumberOfImageToKeep_;
 				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 containerRepository_;
+				std::string containerTag_;
 				std::string sourceId_;
 				bool runOnce_;
-				std::string launchTemplateId_;
 				std::string resourceOwnerAccount_;
-				std::string validTime_;
-				long ownerId_;
+				std::vector<SystemDiskPart> systemDiskPart_;
 				std::vector<DataDisk> dataDisk_;
 				std::string launchTemplateVersion_;
-				std::string vSwitchId_;
-				std::string scheduledStartTime_;
-				std::string instanceId_;
 				std::string vpcId_;
-				std::string name_;
-				int maxNumberOfImageToKeep_;
 
 			};
 		}

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
+std::vector<CreateReplicationJobRequest::SystemDiskPart> CreateReplicationJobRequest::getSystemDiskPart()const
 {
-	return validTime_;
+	return systemDiskPart_;
 }
 
-void CreateReplicationJobRequest::setValidTime(const std::string& validTime)
+void CreateReplicationJobRequest::setSystemDiskPart(const std::vector<SystemDiskPart>& systemDiskPart)
 {
-	validTime_ = validTime;
-	setParameter("ValidTime", validTime);
-}
-
-long CreateReplicationJobRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CreateReplicationJobRequest::setOwnerId(long ownerId)
-{
-	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_;