Add CreateAndStartBackupPlan.

CHANGELOG

@@ -1,3 +1,9 @@
+2021-01-07 Version: patch
+- Add CreateAndStartBackupPlan.
+- Add DescribeDLAService.
+- Add CreateDLAService.
+- Add CloseDLAService.
+
 2021-01-07 Version: patch
 - Generated 2019-09-10 for `waf-openapi`.
 

dbs/CMakeLists.txt

@@ -21,10 +21,16 @@ set(dbs_public_header
 	include/alibabacloud/dbs/DbsExport.h )
 
 set(dbs_public_header_model 
+	include/alibabacloud/dbs/model/CloseDLAServiceRequest.h
+	include/alibabacloud/dbs/model/CloseDLAServiceResult.h
 	include/alibabacloud/dbs/model/ConfigureBackupPlanRequest.h
 	include/alibabacloud/dbs/model/ConfigureBackupPlanResult.h
+	include/alibabacloud/dbs/model/CreateAndStartBackupPlanRequest.h
+	include/alibabacloud/dbs/model/CreateAndStartBackupPlanResult.h
 	include/alibabacloud/dbs/model/CreateBackupPlanRequest.h
 	include/alibabacloud/dbs/model/CreateBackupPlanResult.h
+	include/alibabacloud/dbs/model/CreateDLAServiceRequest.h
+	include/alibabacloud/dbs/model/CreateDLAServiceResult.h
 	include/alibabacloud/dbs/model/CreateFullBackupSetDownloadRequest.h
 	include/alibabacloud/dbs/model/CreateFullBackupSetDownloadResult.h
 	include/alibabacloud/dbs/model/CreateGetDBListFromAgentTaskRequest.h
@@ -41,6 +47,8 @@ set(dbs_public_header_model
 	include/alibabacloud/dbs/model/DescribeBackupPlanListResult.h
 	include/alibabacloud/dbs/model/DescribeBackupSetDownloadTaskListRequest.h
 	include/alibabacloud/dbs/model/DescribeBackupSetDownloadTaskListResult.h
+	include/alibabacloud/dbs/model/DescribeDLAServiceRequest.h
+	include/alibabacloud/dbs/model/DescribeDLAServiceResult.h
 	include/alibabacloud/dbs/model/DescribeFullBackupListRequest.h
 	include/alibabacloud/dbs/model/DescribeFullBackupListResult.h
 	include/alibabacloud/dbs/model/DescribeIncrementBackupListRequest.h
@@ -83,8 +91,6 @@ set(dbs_public_header_model
 	include/alibabacloud/dbs/model/StartBackupPlanResult.h
 	include/alibabacloud/dbs/model/StartRestoreTaskRequest.h
 	include/alibabacloud/dbs/model/StartRestoreTaskResult.h
-	include/alibabacloud/dbs/model/StartTaskRequest.h
-	include/alibabacloud/dbs/model/StartTaskResult.h
 	include/alibabacloud/dbs/model/StopBackupPlanRequest.h
 	include/alibabacloud/dbs/model/StopBackupPlanResult.h
 	include/alibabacloud/dbs/model/UpgradeBackupPlanRequest.h
@@ -92,10 +98,16 @@ set(dbs_public_header_model
 
 set(dbs_src 
 	src/DbsClient.cc
+	src/model/CloseDLAServiceRequest.cc
+	src/model/CloseDLAServiceResult.cc
 	src/model/ConfigureBackupPlanRequest.cc
 	src/model/ConfigureBackupPlanResult.cc
+	src/model/CreateAndStartBackupPlanRequest.cc
+	src/model/CreateAndStartBackupPlanResult.cc
 	src/model/CreateBackupPlanRequest.cc
 	src/model/CreateBackupPlanResult.cc
+	src/model/CreateDLAServiceRequest.cc
+	src/model/CreateDLAServiceResult.cc
 	src/model/CreateFullBackupSetDownloadRequest.cc
 	src/model/CreateFullBackupSetDownloadResult.cc
 	src/model/CreateGetDBListFromAgentTaskRequest.cc
@@ -112,6 +124,8 @@ set(dbs_src
 	src/model/DescribeBackupPlanListResult.cc
 	src/model/DescribeBackupSetDownloadTaskListRequest.cc
 	src/model/DescribeBackupSetDownloadTaskListResult.cc
+	src/model/DescribeDLAServiceRequest.cc
+	src/model/DescribeDLAServiceResult.cc
 	src/model/DescribeFullBackupListRequest.cc
 	src/model/DescribeFullBackupListResult.cc
 	src/model/DescribeIncrementBackupListRequest.cc
@@ -154,8 +168,6 @@ set(dbs_src
 	src/model/StartBackupPlanResult.cc
 	src/model/StartRestoreTaskRequest.cc
 	src/model/StartRestoreTaskResult.cc
-	src/model/StartTaskRequest.cc
-	src/model/StartTaskResult.cc
 	src/model/StopBackupPlanRequest.cc
 	src/model/StopBackupPlanResult.cc
 	src/model/UpgradeBackupPlanRequest.cc

dbs/include/alibabacloud/dbs/DbsClient.h

@@ -22,10 +22,16 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "DbsExport.h"
+#include "model/CloseDLAServiceRequest.h"
+#include "model/CloseDLAServiceResult.h"
 #include "model/ConfigureBackupPlanRequest.h"
 #include "model/ConfigureBackupPlanResult.h"
+#include "model/CreateAndStartBackupPlanRequest.h"
+#include "model/CreateAndStartBackupPlanResult.h"
 #include "model/CreateBackupPlanRequest.h"
 #include "model/CreateBackupPlanResult.h"
+#include "model/CreateDLAServiceRequest.h"
+#include "model/CreateDLAServiceResult.h"
 #include "model/CreateFullBackupSetDownloadRequest.h"
 #include "model/CreateFullBackupSetDownloadResult.h"
 #include "model/CreateGetDBListFromAgentTaskRequest.h"
@@ -42,6 +48,8 @@
 #include "model/DescribeBackupPlanListResult.h"
 #include "model/DescribeBackupSetDownloadTaskListRequest.h"
 #include "model/DescribeBackupSetDownloadTaskListResult.h"
+#include "model/DescribeDLAServiceRequest.h"
+#include "model/DescribeDLAServiceResult.h"
 #include "model/DescribeFullBackupListRequest.h"
 #include "model/DescribeFullBackupListResult.h"
 #include "model/DescribeIncrementBackupListRequest.h"
@@ -84,8 +92,6 @@
 #include "model/StartBackupPlanResult.h"
 #include "model/StartRestoreTaskRequest.h"
 #include "model/StartRestoreTaskResult.h"
-#include "model/StartTaskRequest.h"
-#include "model/StartTaskResult.h"
 #include "model/StopBackupPlanRequest.h"
 #include "model/StopBackupPlanResult.h"
 #include "model/UpgradeBackupPlanRequest.h"
@@ -99,12 +105,21 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_DBS_EXPORT DbsClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::CloseDLAServiceResult> CloseDLAServiceOutcome;
+			typedef std::future<CloseDLAServiceOutcome> CloseDLAServiceOutcomeCallable;
+			typedef std::function<void(const DbsClient*, const Model::CloseDLAServiceRequest&, const CloseDLAServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloseDLAServiceAsyncHandler;
 			typedef Outcome<Error, Model::ConfigureBackupPlanResult> ConfigureBackupPlanOutcome;
 			typedef std::future<ConfigureBackupPlanOutcome> ConfigureBackupPlanOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::ConfigureBackupPlanRequest&, const ConfigureBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigureBackupPlanAsyncHandler;
+			typedef Outcome<Error, Model::CreateAndStartBackupPlanResult> CreateAndStartBackupPlanOutcome;
+			typedef std::future<CreateAndStartBackupPlanOutcome> CreateAndStartBackupPlanOutcomeCallable;
+			typedef std::function<void(const DbsClient*, const Model::CreateAndStartBackupPlanRequest&, const CreateAndStartBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAndStartBackupPlanAsyncHandler;
 			typedef Outcome<Error, Model::CreateBackupPlanResult> CreateBackupPlanOutcome;
 			typedef std::future<CreateBackupPlanOutcome> CreateBackupPlanOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::CreateBackupPlanRequest&, const CreateBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupPlanAsyncHandler;
+			typedef Outcome<Error, Model::CreateDLAServiceResult> CreateDLAServiceOutcome;
+			typedef std::future<CreateDLAServiceOutcome> CreateDLAServiceOutcomeCallable;
+			typedef std::function<void(const DbsClient*, const Model::CreateDLAServiceRequest&, const CreateDLAServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDLAServiceAsyncHandler;
 			typedef Outcome<Error, Model::CreateFullBackupSetDownloadResult> CreateFullBackupSetDownloadOutcome;
 			typedef std::future<CreateFullBackupSetDownloadOutcome> CreateFullBackupSetDownloadOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::CreateFullBackupSetDownloadRequest&, const CreateFullBackupSetDownloadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFullBackupSetDownloadAsyncHandler;
@@ -129,6 +144,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeBackupSetDownloadTaskListResult> DescribeBackupSetDownloadTaskListOutcome;
 			typedef std::future<DescribeBackupSetDownloadTaskListOutcome> DescribeBackupSetDownloadTaskListOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::DescribeBackupSetDownloadTaskListRequest&, const DescribeBackupSetDownloadTaskListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupSetDownloadTaskListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDLAServiceResult> DescribeDLAServiceOutcome;
+			typedef std::future<DescribeDLAServiceOutcome> DescribeDLAServiceOutcomeCallable;
+			typedef std::function<void(const DbsClient*, const Model::DescribeDLAServiceRequest&, const DescribeDLAServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDLAServiceAsyncHandler;
 			typedef Outcome<Error, Model::DescribeFullBackupListResult> DescribeFullBackupListOutcome;
 			typedef std::future<DescribeFullBackupListOutcome> DescribeFullBackupListOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::DescribeFullBackupListRequest&, const DescribeFullBackupListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFullBackupListAsyncHandler;
@@ -192,9 +210,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StartRestoreTaskResult> StartRestoreTaskOutcome;
 			typedef std::future<StartRestoreTaskOutcome> StartRestoreTaskOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::StartRestoreTaskRequest&, const StartRestoreTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartRestoreTaskAsyncHandler;
-			typedef Outcome<Error, Model::StartTaskResult> StartTaskOutcome;
-			typedef std::future<StartTaskOutcome> StartTaskOutcomeCallable;
-			typedef std::function<void(const DbsClient*, const Model::StartTaskRequest&, const StartTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartTaskAsyncHandler;
 			typedef Outcome<Error, Model::StopBackupPlanResult> StopBackupPlanOutcome;
 			typedef std::future<StopBackupPlanOutcome> StopBackupPlanOutcomeCallable;
 			typedef std::function<void(const DbsClient*, const Model::StopBackupPlanRequest&, const StopBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopBackupPlanAsyncHandler;
@@ -206,12 +221,21 @@ namespace AlibabaCloud
 			DbsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			DbsClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~DbsClient();
+			CloseDLAServiceOutcome closeDLAService(const Model::CloseDLAServiceRequest &request)const;
+			void closeDLAServiceAsync(const Model::CloseDLAServiceRequest& request, const CloseDLAServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CloseDLAServiceOutcomeCallable closeDLAServiceCallable(const Model::CloseDLAServiceRequest& request) const;
 			ConfigureBackupPlanOutcome configureBackupPlan(const Model::ConfigureBackupPlanRequest &request)const;
 			void configureBackupPlanAsync(const Model::ConfigureBackupPlanRequest& request, const ConfigureBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ConfigureBackupPlanOutcomeCallable configureBackupPlanCallable(const Model::ConfigureBackupPlanRequest& request) const;
+			CreateAndStartBackupPlanOutcome createAndStartBackupPlan(const Model::CreateAndStartBackupPlanRequest &request)const;
+			void createAndStartBackupPlanAsync(const Model::CreateAndStartBackupPlanRequest& request, const CreateAndStartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAndStartBackupPlanOutcomeCallable createAndStartBackupPlanCallable(const Model::CreateAndStartBackupPlanRequest& request) const;
 			CreateBackupPlanOutcome createBackupPlan(const Model::CreateBackupPlanRequest &request)const;
 			void createBackupPlanAsync(const Model::CreateBackupPlanRequest& request, const CreateBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateBackupPlanOutcomeCallable createBackupPlanCallable(const Model::CreateBackupPlanRequest& request) const;
+			CreateDLAServiceOutcome createDLAService(const Model::CreateDLAServiceRequest &request)const;
+			void createDLAServiceAsync(const Model::CreateDLAServiceRequest& request, const CreateDLAServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDLAServiceOutcomeCallable createDLAServiceCallable(const Model::CreateDLAServiceRequest& request) const;
 			CreateFullBackupSetDownloadOutcome createFullBackupSetDownload(const Model::CreateFullBackupSetDownloadRequest &request)const;
 			void createFullBackupSetDownloadAsync(const Model::CreateFullBackupSetDownloadRequest& request, const CreateFullBackupSetDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateFullBackupSetDownloadOutcomeCallable createFullBackupSetDownloadCallable(const Model::CreateFullBackupSetDownloadRequest& request) const;
@@ -236,6 +260,9 @@ namespace AlibabaCloud
 			DescribeBackupSetDownloadTaskListOutcome describeBackupSetDownloadTaskList(const Model::DescribeBackupSetDownloadTaskListRequest &request)const;
 			void describeBackupSetDownloadTaskListAsync(const Model::DescribeBackupSetDownloadTaskListRequest& request, const DescribeBackupSetDownloadTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeBackupSetDownloadTaskListOutcomeCallable describeBackupSetDownloadTaskListCallable(const Model::DescribeBackupSetDownloadTaskListRequest& request) const;
+			DescribeDLAServiceOutcome describeDLAService(const Model::DescribeDLAServiceRequest &request)const;
+			void describeDLAServiceAsync(const Model::DescribeDLAServiceRequest& request, const DescribeDLAServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDLAServiceOutcomeCallable describeDLAServiceCallable(const Model::DescribeDLAServiceRequest& request) const;
 			DescribeFullBackupListOutcome describeFullBackupList(const Model::DescribeFullBackupListRequest &request)const;
 			void describeFullBackupListAsync(const Model::DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeFullBackupListOutcomeCallable describeFullBackupListCallable(const Model::DescribeFullBackupListRequest& request) const;
@@ -299,9 +326,6 @@ namespace AlibabaCloud
 			StartRestoreTaskOutcome startRestoreTask(const Model::StartRestoreTaskRequest &request)const;
 			void startRestoreTaskAsync(const Model::StartRestoreTaskRequest& request, const StartRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartRestoreTaskOutcomeCallable startRestoreTaskCallable(const Model::StartRestoreTaskRequest& request) const;
-			StartTaskOutcome startTask(const Model::StartTaskRequest &request)const;
-			void startTaskAsync(const Model::StartTaskRequest& request, const StartTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			StartTaskOutcomeCallable startTaskCallable(const Model::StartTaskRequest& request) const;
 			StopBackupPlanOutcome stopBackupPlan(const Model::StopBackupPlanRequest &request)const;
 			void stopBackupPlanAsync(const Model::StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopBackupPlanOutcomeCallable stopBackupPlanCallable(const Model::StopBackupPlanRequest& request) const;

dbs/include/alibabacloud/dbs/model/StartTaskRequest.h → dbs/include/alibabacloud/dbs/model/CloseDLAServiceRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DBS_MODEL_STARTTASKREQUEST_H_
-#define ALIBABACLOUD_DBS_MODEL_STARTTASKREQUEST_H_
+#ifndef ALIBABACLOUD_DBS_MODEL_CLOSEDLASERVICEREQUEST_H_
+#define ALIBABACLOUD_DBS_MODEL_CLOSEDLASERVICEREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,27 +28,27 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DBS_EXPORT StartTaskRequest : public RpcServiceRequest
+			class ALIBABACLOUD_DBS_EXPORT CloseDLAServiceRequest : public RpcServiceRequest
 			{
 
 			public:
-				StartTaskRequest();
-				~StartTaskRequest();
+				CloseDLAServiceRequest();
+				~CloseDLAServiceRequest();
 
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
+				std::string getBackupPlanId()const;
+				void setBackupPlanId(const std::string& backupPlanId);
 				std::string getOwnerId()const;
 				void setOwnerId(const std::string& ownerId);
-				std::string getTaskId()const;
-				void setTaskId(const std::string& taskId);
 
             private:
 				std::string clientToken_;
+				std::string backupPlanId_;
 				std::string ownerId_;
-				std::string taskId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DBS_MODEL_STARTTASKREQUEST_H_
+#endif // !ALIBABACLOUD_DBS_MODEL_CLOSEDLASERVICEREQUEST_H_

dbs/include/alibabacloud/dbs/model/StartTaskResult.h → dbs/include/alibabacloud/dbs/model/CloseDLAServiceResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DBS_MODEL_STARTTASKRESULT_H_
-#define ALIBABACLOUD_DBS_MODEL_STARTTASKRESULT_H_
+#ifndef ALIBABACLOUD_DBS_MODEL_CLOSEDLASERVICERESULT_H_
+#define ALIBABACLOUD_DBS_MODEL_CLOSEDLASERVICERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,33 +29,29 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DBS_EXPORT StartTaskResult : public ServiceResult
+			class ALIBABACLOUD_DBS_EXPORT CloseDLAServiceResult : public ServiceResult
 			{
 			public:
 
 
-				StartTaskResult();
-				explicit StartTaskResult(const std::string &payload);
-				~StartTaskResult();
-				std::string getTaskId()const;
+				CloseDLAServiceResult();
+				explicit CloseDLAServiceResult(const std::string &payload);
+				~CloseDLAServiceResult();
 				int getHttpStatusCode()const;
 				std::string getErrMessage()const;
 				bool getSuccess()const;
 				std::string getErrCode()const;
-				std::string getJobTypeName()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string taskId_;
 				int httpStatusCode_;
 				std::string errMessage_;
 				bool success_;
 				std::string errCode_;
-				std::string jobTypeName_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DBS_MODEL_STARTTASKRESULT_H_
+#endif // !ALIBABACLOUD_DBS_MODEL_CLOSEDLASERVICERESULT_H_

dbs/include/alibabacloud/dbs/model/CreateAndStartBackupPlanRequest.h

@@ -0,0 +1,168 @@
+/*
+ * 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_DBS_MODEL_CREATEANDSTARTBACKUPPLANREQUEST_H_
+#define ALIBABACLOUD_DBS_MODEL_CREATEANDSTARTBACKUPPLANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbs/DbsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dbs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBS_EXPORT CreateAndStartBackupPlanRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateAndStartBackupPlanRequest();
+				~CreateAndStartBackupPlanRequest();
+
+				std::string getDatabaseType()const;
+				void setDatabaseType(const std::string& databaseType);
+				long getBackupGatewayId()const;
+				void setBackupGatewayId(long backupGatewayId);
+				std::string getSourceEndpointUserName()const;
+				void setSourceEndpointUserName(const std::string& sourceEndpointUserName);
+				std::string getStorageType()const;
+				void setStorageType(const std::string& storageType);
+				std::string getDatabaseRegion()const;
+				void setDatabaseRegion(const std::string& databaseRegion);
+				std::string getBackupStartTime()const;
+				void setBackupStartTime(const std::string& backupStartTime);
+				std::string getSourceEndpointIP()const;
+				void setSourceEndpointIP(const std::string& sourceEndpointIP);
+				std::string getCrossRoleName()const;
+				void setCrossRoleName(const std::string& crossRoleName);
+				std::string getBackupStorageType()const;
+				void setBackupStorageType(const std::string& backupStorageType);
+				int getDuplicationArchivePeriod()const;
+				void setDuplicationArchivePeriod(int duplicationArchivePeriod);
+				std::string getPeriod()const;
+				void setPeriod(const std::string& period);
+				int getBackupLogIntervalSeconds()const;
+				void setBackupLogIntervalSeconds(int backupLogIntervalSeconds);
+				std::string getFromApp()const;
+				void setFromApp(const std::string& fromApp);
+				std::string getSourceEndpointPassword()const;
+				void setSourceEndpointPassword(const std::string& sourceEndpointPassword);
+				std::string getOwnerId()const;
+				void setOwnerId(const std::string& ownerId);
+				std::string getBackupMethod()const;
+				void setBackupMethod(const std::string& backupMethod);
+				int getBackupRetentionPeriod()const;
+				void setBackupRetentionPeriod(int backupRetentionPeriod);
+				std::string getBackupPeriod()const;
+				void setBackupPeriod(const std::string& backupPeriod);
+				long getBackupSpeedLimit()const;
+				void setBackupSpeedLimit(long backupSpeedLimit);
+				std::string getSourceEndpointInstanceType()const;
+				void setSourceEndpointInstanceType(const std::string& sourceEndpointInstanceType);
+				std::string getBackupPlanName()const;
+				void setBackupPlanName(const std::string& backupPlanName);
+				std::string getOSSBucketName()const;
+				void setOSSBucketName(const std::string& oSSBucketName);
+				std::string getRegion()const;
+				void setRegion(const std::string& region);
+				std::string getSourceEndpointRegion()const;
+				void setSourceEndpointRegion(const std::string& sourceEndpointRegion);
+				std::string getSourceEndpointInstanceID()const;
+				void setSourceEndpointInstanceID(const std::string& sourceEndpointInstanceID);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getBackupPlanId()const;
+				void setBackupPlanId(const std::string& backupPlanId);
+				std::string getInstanceClass()const;
+				void setInstanceClass(const std::string& instanceClass);
+				std::string getSourceEndpointDatabaseName()const;
+				void setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName);
+				int getDuplicationInfrequentAccessPeriod()const;
+				void setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+				bool getEnableBackupLog()const;
+				void setEnableBackupLog(bool enableBackupLog);
+				std::string getCrossAliyunId()const;
+				void setCrossAliyunId(const std::string& crossAliyunId);
+				std::string getBackupObjects()const;
+				void setBackupObjects(const std::string& backupObjects);
+				long getBackupRateLimit()const;
+				void setBackupRateLimit(long backupRateLimit);
+				int getUsedTime()const;
+				void setUsedTime(int usedTime);
+				int getSourceEndpointPort()const;
+				void setSourceEndpointPort(int sourceEndpointPort);
+				std::string getStorageRegion()const;
+				void setStorageRegion(const std::string& storageRegion);
+				std::string getSourceEndpointOracleSID()const;
+				void setSourceEndpointOracleSID(const std::string& sourceEndpointOracleSID);
+				std::string getBackupStrategyType()const;
+				void setBackupStrategyType(const std::string& backupStrategyType);
+				std::string getPayType()const;
+				void setPayType(const std::string& payType);
+
+            private:
+				std::string databaseType_;
+				long backupGatewayId_;
+				std::string sourceEndpointUserName_;
+				std::string storageType_;
+				std::string databaseRegion_;
+				std::string backupStartTime_;
+				std::string sourceEndpointIP_;
+				std::string crossRoleName_;
+				std::string backupStorageType_;
+				int duplicationArchivePeriod_;
+				std::string period_;
+				int backupLogIntervalSeconds_;
+				std::string fromApp_;
+				std::string sourceEndpointPassword_;
+				std::string ownerId_;
+				std::string backupMethod_;
+				int backupRetentionPeriod_;
+				std::string backupPeriod_;
+				long backupSpeedLimit_;
+				std::string sourceEndpointInstanceType_;
+				std::string backupPlanName_;
+				std::string oSSBucketName_;
+				std::string region_;
+				std::string sourceEndpointRegion_;
+				std::string sourceEndpointInstanceID_;
+				std::string clientToken_;
+				std::string backupPlanId_;
+				std::string instanceClass_;
+				std::string sourceEndpointDatabaseName_;
+				int duplicationInfrequentAccessPeriod_;
+				std::string instanceType_;
+				bool enableBackupLog_;
+				std::string crossAliyunId_;
+				std::string backupObjects_;
+				long backupRateLimit_;
+				int usedTime_;
+				int sourceEndpointPort_;
+				std::string storageRegion_;
+				std::string sourceEndpointOracleSID_;
+				std::string backupStrategyType_;
+				std::string payType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBS_MODEL_CREATEANDSTARTBACKUPPLANREQUEST_H_

dbs/include/alibabacloud/dbs/model/CreateAndStartBackupPlanResult.h

@@ -0,0 +1,61 @@
+/*
+ * 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_DBS_MODEL_CREATEANDSTARTBACKUPPLANRESULT_H_
+#define ALIBABACLOUD_DBS_MODEL_CREATEANDSTARTBACKUPPLANRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbs/DbsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dbs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBS_EXPORT CreateAndStartBackupPlanResult : public ServiceResult
+			{
+			public:
+
+
+				CreateAndStartBackupPlanResult();
+				explicit CreateAndStartBackupPlanResult(const std::string &payload);
+				~CreateAndStartBackupPlanResult();
+				int getHttpStatusCode()const;
+				std::string getBackupPlanId()const;
+				std::string getErrMessage()const;
+				std::string getOrderId()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string backupPlanId_;
+				std::string errMessage_;
+				std::string orderId_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBS_MODEL_CREATEANDSTARTBACKUPPLANRESULT_H_

dbs/include/alibabacloud/dbs/model/CreateDLAServiceRequest.h

@@ -0,0 +1,60 @@
+/*
+ * 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_DBS_MODEL_CREATEDLASERVICEREQUEST_H_
+#define ALIBABACLOUD_DBS_MODEL_CREATEDLASERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbs/DbsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dbs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBS_EXPORT CreateDLAServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDLAServiceRequest();
+				~CreateDLAServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				bool getAutoAdd()const;
+				void setAutoAdd(bool autoAdd);
+				std::string getBackupSetIds()const;
+				void setBackupSetIds(const std::string& backupSetIds);
+				std::string getBackupPlanId()const;
+				void setBackupPlanId(const std::string& backupPlanId);
+				std::string getOwnerId()const;
+				void setOwnerId(const std::string& ownerId);
+
+            private:
+				std::string clientToken_;
+				bool autoAdd_;
+				std::string backupSetIds_;
+				std::string backupPlanId_;
+				std::string ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBS_MODEL_CREATEDLASERVICEREQUEST_H_

dbs/include/alibabacloud/dbs/model/CreateDLAServiceResult.h

@@ -0,0 +1,57 @@
+/*
+ * 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_DBS_MODEL_CREATEDLASERVICERESULT_H_
+#define ALIBABACLOUD_DBS_MODEL_CREATEDLASERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbs/DbsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dbs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBS_EXPORT CreateDLAServiceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDLAServiceResult();
+				explicit CreateDLAServiceResult(const std::string &payload);
+				~CreateDLAServiceResult();
+				int getHttpStatusCode()const;
+				std::string getErrMessage()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string errMessage_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBS_MODEL_CREATEDLASERVICERESULT_H_

dbs/include/alibabacloud/dbs/model/DescribeDLAServiceRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_DBS_MODEL_DESCRIBEDLASERVICEREQUEST_H_
+#define ALIBABACLOUD_DBS_MODEL_DESCRIBEDLASERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbs/DbsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dbs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBS_EXPORT DescribeDLAServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDLAServiceRequest();
+				~DescribeDLAServiceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getBackupPlanId()const;
+				void setBackupPlanId(const std::string& backupPlanId);
+				std::string getOwnerId()const;
+				void setOwnerId(const std::string& ownerId);
+
+            private:
+				std::string clientToken_;
+				std::string backupPlanId_;
+				std::string ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBS_MODEL_DESCRIBEDLASERVICEREQUEST_H_

dbs/include/alibabacloud/dbs/model/DescribeDLAServiceResult.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_DBS_MODEL_DESCRIBEDLASERVICERESULT_H_
+#define ALIBABACLOUD_DBS_MODEL_DESCRIBEDLASERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbs/DbsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dbs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBS_EXPORT DescribeDLAServiceResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDLAServiceResult();
+				explicit DescribeDLAServiceResult(const std::string &payload);
+				~DescribeDLAServiceResult();
+				bool getAutoAdd()const;
+				bool getHaveJobFailed()const;
+				std::string getState()const;
+				int getHttpStatusCode()const;
+				std::string getErrMessage()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool autoAdd_;
+				bool haveJobFailed_;
+				std::string state_;
+				int httpStatusCode_;
+				std::string errMessage_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBS_MODEL_DESCRIBEDLASERVICERESULT_H_

dbs/src/DbsClient.cc

@@ -51,6 +51,42 @@ DbsClient::DbsClient(const std::string & accessKeyId, const std::string & access
 DbsClient::~DbsClient()
 {}
 
+DbsClient::CloseDLAServiceOutcome DbsClient::closeDLAService(const CloseDLAServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CloseDLAServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CloseDLAServiceOutcome(CloseDLAServiceResult(outcome.result()));
+	else
+		return CloseDLAServiceOutcome(outcome.error());
+}
+
+void DbsClient::closeDLAServiceAsync(const CloseDLAServiceRequest& request, const CloseDLAServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, closeDLAService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DbsClient::CloseDLAServiceOutcomeCallable DbsClient::closeDLAServiceCallable(const CloseDLAServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CloseDLAServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->closeDLAService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DbsClient::ConfigureBackupPlanOutcome DbsClient::configureBackupPlan(const ConfigureBackupPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -87,6 +123,42 @@ DbsClient::ConfigureBackupPlanOutcomeCallable DbsClient::configureBackupPlanCall
 	return task->get_future();
 }
 
+DbsClient::CreateAndStartBackupPlanOutcome DbsClient::createAndStartBackupPlan(const CreateAndStartBackupPlanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateAndStartBackupPlanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateAndStartBackupPlanOutcome(CreateAndStartBackupPlanResult(outcome.result()));
+	else
+		return CreateAndStartBackupPlanOutcome(outcome.error());
+}
+
+void DbsClient::createAndStartBackupPlanAsync(const CreateAndStartBackupPlanRequest& request, const CreateAndStartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createAndStartBackupPlan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DbsClient::CreateAndStartBackupPlanOutcomeCallable DbsClient::createAndStartBackupPlanCallable(const CreateAndStartBackupPlanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateAndStartBackupPlanOutcome()>>(
+			[this, request]()
+			{
+			return this->createAndStartBackupPlan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DbsClient::CreateBackupPlanOutcome DbsClient::createBackupPlan(const CreateBackupPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -123,6 +195,42 @@ DbsClient::CreateBackupPlanOutcomeCallable DbsClient::createBackupPlanCallable(c
 	return task->get_future();
 }
 
+DbsClient::CreateDLAServiceOutcome DbsClient::createDLAService(const CreateDLAServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDLAServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDLAServiceOutcome(CreateDLAServiceResult(outcome.result()));
+	else
+		return CreateDLAServiceOutcome(outcome.error());
+}
+
+void DbsClient::createDLAServiceAsync(const CreateDLAServiceRequest& request, const CreateDLAServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDLAService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DbsClient::CreateDLAServiceOutcomeCallable DbsClient::createDLAServiceCallable(const CreateDLAServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDLAServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->createDLAService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DbsClient::CreateFullBackupSetDownloadOutcome DbsClient::createFullBackupSetDownload(const CreateFullBackupSetDownloadRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -411,6 +519,42 @@ DbsClient::DescribeBackupSetDownloadTaskListOutcomeCallable DbsClient::describeB
 	return task->get_future();
 }
 
+DbsClient::DescribeDLAServiceOutcome DbsClient::describeDLAService(const DescribeDLAServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDLAServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDLAServiceOutcome(DescribeDLAServiceResult(outcome.result()));
+	else
+		return DescribeDLAServiceOutcome(outcome.error());
+}
+
+void DbsClient::describeDLAServiceAsync(const DescribeDLAServiceRequest& request, const DescribeDLAServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDLAService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DbsClient::DescribeDLAServiceOutcomeCallable DbsClient::describeDLAServiceCallable(const DescribeDLAServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDLAServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDLAService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DbsClient::DescribeFullBackupListOutcome DbsClient::describeFullBackupList(const DescribeFullBackupListRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1167,42 +1311,6 @@ DbsClient::StartRestoreTaskOutcomeCallable DbsClient::startRestoreTaskCallable(c
 	return task->get_future();
 }
 
-DbsClient::StartTaskOutcome DbsClient::startTask(const StartTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return StartTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return StartTaskOutcome(StartTaskResult(outcome.result()));
-	else
-		return StartTaskOutcome(outcome.error());
-}
-
-void DbsClient::startTaskAsync(const StartTaskRequest& request, const StartTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, startTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-DbsClient::StartTaskOutcomeCallable DbsClient::startTaskCallable(const StartTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<StartTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->startTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 DbsClient::StopBackupPlanOutcome DbsClient::stopBackupPlan(const StopBackupPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dbs/src/model/StartTaskRequest.cc → dbs/src/model/CloseDLAServiceRequest.cc

@@ -14,49 +14,49 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/dbs/model/StartTaskRequest.h>
+#include <alibabacloud/dbs/model/CloseDLAServiceRequest.h>
 
-using AlibabaCloud::Dbs::Model::StartTaskRequest;
+using AlibabaCloud::Dbs::Model::CloseDLAServiceRequest;
 
-StartTaskRequest::StartTaskRequest() :
-	RpcServiceRequest("dbs", "2019-03-06", "StartTask")
+CloseDLAServiceRequest::CloseDLAServiceRequest() :
+	RpcServiceRequest("dbs", "2019-03-06", "CloseDLAService")
 {
 	setMethod(HttpRequest::Method::Post);
 }
 
-StartTaskRequest::~StartTaskRequest()
+CloseDLAServiceRequest::~CloseDLAServiceRequest()
 {}
 
-std::string StartTaskRequest::getClientToken()const
+std::string CloseDLAServiceRequest::getClientToken()const
 {
 	return clientToken_;
 }
 
-void StartTaskRequest::setClientToken(const std::string& clientToken)
+void CloseDLAServiceRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
 	setParameter("ClientToken", clientToken);
 }
 
-std::string StartTaskRequest::getOwnerId()const
+std::string CloseDLAServiceRequest::getBackupPlanId()const
 {
-	return ownerId_;
+	return backupPlanId_;
 }
 
-void StartTaskRequest::setOwnerId(const std::string& ownerId)
+void CloseDLAServiceRequest::setBackupPlanId(const std::string& backupPlanId)
 {
-	ownerId_ = ownerId;
-	setParameter("OwnerId", ownerId);
+	backupPlanId_ = backupPlanId;
+	setParameter("BackupPlanId", backupPlanId);
 }
 
-std::string StartTaskRequest::getTaskId()const
+std::string CloseDLAServiceRequest::getOwnerId()const
 {
-	return taskId_;
+	return ownerId_;
 }
 
-void StartTaskRequest::setTaskId(const std::string& taskId)
+void CloseDLAServiceRequest::setOwnerId(const std::string& ownerId)
 {
-	taskId_ = taskId;
-	setParameter("TaskId", taskId);
+	ownerId_ = ownerId;
+	setParameter("OwnerId", ownerId);
 }
 

dbs/src/model/StartTaskResult.cc → dbs/src/model/CloseDLAServiceResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/dbs/model/StartTaskResult.h>
+#include <alibabacloud/dbs/model/CloseDLAServiceResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Dbs;
 using namespace AlibabaCloud::Dbs::Model;
 
-StartTaskResult::StartTaskResult() :
+CloseDLAServiceResult::CloseDLAServiceResult() :
 	ServiceResult()
 {}
 
-StartTaskResult::StartTaskResult(const std::string &payload) :
+CloseDLAServiceResult::CloseDLAServiceResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-StartTaskResult::~StartTaskResult()
+CloseDLAServiceResult::~CloseDLAServiceResult()
 {}
 
-void StartTaskResult::parse(const std::string &payload)
+void CloseDLAServiceResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -47,40 +47,26 @@ void StartTaskResult::parse(const std::string &payload)
 		errMessage_ = value["ErrMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
-	if(!value["TaskId"].isNull())
-		taskId_ = value["TaskId"].asString();
-	if(!value["JobTypeName"].isNull())
-		jobTypeName_ = value["JobTypeName"].asString();
 
 }
 
-std::string StartTaskResult::getTaskId()const
-{
-	return taskId_;
-}
-
-int StartTaskResult::getHttpStatusCode()const
+int CloseDLAServiceResult::getHttpStatusCode()const
 {
 	return httpStatusCode_;
 }
 
-std::string StartTaskResult::getErrMessage()const
+std::string CloseDLAServiceResult::getErrMessage()const
 {
 	return errMessage_;
 }
 
-bool StartTaskResult::getSuccess()const
+bool CloseDLAServiceResult::getSuccess()const
 {
 	return success_;
 }
 
-std::string StartTaskResult::getErrCode()const
+std::string CloseDLAServiceResult::getErrCode()const
 {
 	return errCode_;
 }
 
-std::string StartTaskResult::getJobTypeName()const
-{
-	return jobTypeName_;
-}
-

dbs/src/model/CreateAndStartBackupPlanRequest.cc

@@ -0,0 +1,480 @@
+/*
+ * 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/dbs/model/CreateAndStartBackupPlanRequest.h>
+
+using AlibabaCloud::Dbs::Model::CreateAndStartBackupPlanRequest;
+
+CreateAndStartBackupPlanRequest::CreateAndStartBackupPlanRequest() :
+	RpcServiceRequest("dbs", "2019-03-06", "CreateAndStartBackupPlan")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateAndStartBackupPlanRequest::~CreateAndStartBackupPlanRequest()
+{}
+
+std::string CreateAndStartBackupPlanRequest::getDatabaseType()const
+{
+	return databaseType_;
+}
+
+void CreateAndStartBackupPlanRequest::setDatabaseType(const std::string& databaseType)
+{
+	databaseType_ = databaseType;
+	setParameter("DatabaseType", databaseType);
+}
+
+long CreateAndStartBackupPlanRequest::getBackupGatewayId()const
+{
+	return backupGatewayId_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupGatewayId(long backupGatewayId)
+{
+	backupGatewayId_ = backupGatewayId;
+	setParameter("BackupGatewayId", std::to_string(backupGatewayId));
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointUserName()const
+{
+	return sourceEndpointUserName_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointUserName(const std::string& sourceEndpointUserName)
+{
+	sourceEndpointUserName_ = sourceEndpointUserName;
+	setParameter("SourceEndpointUserName", sourceEndpointUserName);
+}
+
+std::string CreateAndStartBackupPlanRequest::getStorageType()const
+{
+	return storageType_;
+}
+
+void CreateAndStartBackupPlanRequest::setStorageType(const std::string& storageType)
+{
+	storageType_ = storageType;
+	setParameter("StorageType", storageType);
+}
+
+std::string CreateAndStartBackupPlanRequest::getDatabaseRegion()const
+{
+	return databaseRegion_;
+}
+
+void CreateAndStartBackupPlanRequest::setDatabaseRegion(const std::string& databaseRegion)
+{
+	databaseRegion_ = databaseRegion;
+	setParameter("DatabaseRegion", databaseRegion);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupStartTime()const
+{
+	return backupStartTime_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupStartTime(const std::string& backupStartTime)
+{
+	backupStartTime_ = backupStartTime;
+	setParameter("BackupStartTime", backupStartTime);
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointIP()const
+{
+	return sourceEndpointIP_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
+{
+	sourceEndpointIP_ = sourceEndpointIP;
+	setParameter("SourceEndpointIP", sourceEndpointIP);
+}
+
+std::string CreateAndStartBackupPlanRequest::getCrossRoleName()const
+{
+	return crossRoleName_;
+}
+
+void CreateAndStartBackupPlanRequest::setCrossRoleName(const std::string& crossRoleName)
+{
+	crossRoleName_ = crossRoleName;
+	setParameter("CrossRoleName", crossRoleName);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupStorageType()const
+{
+	return backupStorageType_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupStorageType(const std::string& backupStorageType)
+{
+	backupStorageType_ = backupStorageType;
+	setParameter("BackupStorageType", backupStorageType);
+}
+
+int CreateAndStartBackupPlanRequest::getDuplicationArchivePeriod()const
+{
+	return duplicationArchivePeriod_;
+}
+
+void CreateAndStartBackupPlanRequest::setDuplicationArchivePeriod(int duplicationArchivePeriod)
+{
+	duplicationArchivePeriod_ = duplicationArchivePeriod;
+	setParameter("DuplicationArchivePeriod", std::to_string(duplicationArchivePeriod));
+}
+
+std::string CreateAndStartBackupPlanRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateAndStartBackupPlanRequest::setPeriod(const std::string& period)
+{
+	period_ = period;
+	setParameter("Period", period);
+}
+
+int CreateAndStartBackupPlanRequest::getBackupLogIntervalSeconds()const
+{
+	return backupLogIntervalSeconds_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupLogIntervalSeconds(int backupLogIntervalSeconds)
+{
+	backupLogIntervalSeconds_ = backupLogIntervalSeconds;
+	setParameter("BackupLogIntervalSeconds", std::to_string(backupLogIntervalSeconds));
+}
+
+std::string CreateAndStartBackupPlanRequest::getFromApp()const
+{
+	return fromApp_;
+}
+
+void CreateAndStartBackupPlanRequest::setFromApp(const std::string& fromApp)
+{
+	fromApp_ = fromApp;
+	setParameter("FromApp", fromApp);
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointPassword()const
+{
+	return sourceEndpointPassword_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
+{
+	sourceEndpointPassword_ = sourceEndpointPassword;
+	setParameter("SourceEndpointPassword", sourceEndpointPassword);
+}
+
+std::string CreateAndStartBackupPlanRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateAndStartBackupPlanRequest::setOwnerId(const std::string& ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", ownerId);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupMethod()const
+{
+	return backupMethod_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupMethod(const std::string& backupMethod)
+{
+	backupMethod_ = backupMethod;
+	setParameter("BackupMethod", backupMethod);
+}
+
+int CreateAndStartBackupPlanRequest::getBackupRetentionPeriod()const
+{
+	return backupRetentionPeriod_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupRetentionPeriod(int backupRetentionPeriod)
+{
+	backupRetentionPeriod_ = backupRetentionPeriod;
+	setParameter("BackupRetentionPeriod", std::to_string(backupRetentionPeriod));
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupPeriod()const
+{
+	return backupPeriod_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupPeriod(const std::string& backupPeriod)
+{
+	backupPeriod_ = backupPeriod;
+	setParameter("BackupPeriod", backupPeriod);
+}
+
+long CreateAndStartBackupPlanRequest::getBackupSpeedLimit()const
+{
+	return backupSpeedLimit_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupSpeedLimit(long backupSpeedLimit)
+{
+	backupSpeedLimit_ = backupSpeedLimit;
+	setParameter("BackupSpeedLimit", std::to_string(backupSpeedLimit));
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointInstanceType()const
+{
+	return sourceEndpointInstanceType_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointInstanceType(const std::string& sourceEndpointInstanceType)
+{
+	sourceEndpointInstanceType_ = sourceEndpointInstanceType;
+	setParameter("SourceEndpointInstanceType", sourceEndpointInstanceType);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupPlanName()const
+{
+	return backupPlanName_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupPlanName(const std::string& backupPlanName)
+{
+	backupPlanName_ = backupPlanName;
+	setParameter("BackupPlanName", backupPlanName);
+}
+
+std::string CreateAndStartBackupPlanRequest::getOSSBucketName()const
+{
+	return oSSBucketName_;
+}
+
+void CreateAndStartBackupPlanRequest::setOSSBucketName(const std::string& oSSBucketName)
+{
+	oSSBucketName_ = oSSBucketName;
+	setParameter("OSSBucketName", oSSBucketName);
+}
+
+std::string CreateAndStartBackupPlanRequest::getRegion()const
+{
+	return region_;
+}
+
+void CreateAndStartBackupPlanRequest::setRegion(const std::string& region)
+{
+	region_ = region;
+	setParameter("Region", region);
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointRegion()const
+{
+	return sourceEndpointRegion_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointRegion(const std::string& sourceEndpointRegion)
+{
+	sourceEndpointRegion_ = sourceEndpointRegion;
+	setParameter("SourceEndpointRegion", sourceEndpointRegion);
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointInstanceID()const
+{
+	return sourceEndpointInstanceID_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointInstanceID(const std::string& sourceEndpointInstanceID)
+{
+	sourceEndpointInstanceID_ = sourceEndpointInstanceID;
+	setParameter("SourceEndpointInstanceID", sourceEndpointInstanceID);
+}
+
+std::string CreateAndStartBackupPlanRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateAndStartBackupPlanRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupPlanId()const
+{
+	return backupPlanId_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupPlanId(const std::string& backupPlanId)
+{
+	backupPlanId_ = backupPlanId;
+	setParameter("BackupPlanId", backupPlanId);
+}
+
+std::string CreateAndStartBackupPlanRequest::getInstanceClass()const
+{
+	return instanceClass_;
+}
+
+void CreateAndStartBackupPlanRequest::setInstanceClass(const std::string& instanceClass)
+{
+	instanceClass_ = instanceClass;
+	setParameter("InstanceClass", instanceClass);
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointDatabaseName()const
+{
+	return sourceEndpointDatabaseName_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
+{
+	sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
+	setParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
+}
+
+int CreateAndStartBackupPlanRequest::getDuplicationInfrequentAccessPeriod()const
+{
+	return duplicationInfrequentAccessPeriod_;
+}
+
+void CreateAndStartBackupPlanRequest::setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod)
+{
+	duplicationInfrequentAccessPeriod_ = duplicationInfrequentAccessPeriod;
+	setParameter("DuplicationInfrequentAccessPeriod", std::to_string(duplicationInfrequentAccessPeriod));
+}
+
+std::string CreateAndStartBackupPlanRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void CreateAndStartBackupPlanRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+bool CreateAndStartBackupPlanRequest::getEnableBackupLog()const
+{
+	return enableBackupLog_;
+}
+
+void CreateAndStartBackupPlanRequest::setEnableBackupLog(bool enableBackupLog)
+{
+	enableBackupLog_ = enableBackupLog;
+	setParameter("EnableBackupLog", enableBackupLog ? "true" : "false");
+}
+
+std::string CreateAndStartBackupPlanRequest::getCrossAliyunId()const
+{
+	return crossAliyunId_;
+}
+
+void CreateAndStartBackupPlanRequest::setCrossAliyunId(const std::string& crossAliyunId)
+{
+	crossAliyunId_ = crossAliyunId;
+	setParameter("CrossAliyunId", crossAliyunId);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupObjects()const
+{
+	return backupObjects_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupObjects(const std::string& backupObjects)
+{
+	backupObjects_ = backupObjects;
+	setParameter("BackupObjects", backupObjects);
+}
+
+long CreateAndStartBackupPlanRequest::getBackupRateLimit()const
+{
+	return backupRateLimit_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupRateLimit(long backupRateLimit)
+{
+	backupRateLimit_ = backupRateLimit;
+	setParameter("BackupRateLimit", std::to_string(backupRateLimit));
+}
+
+int CreateAndStartBackupPlanRequest::getUsedTime()const
+{
+	return usedTime_;
+}
+
+void CreateAndStartBackupPlanRequest::setUsedTime(int usedTime)
+{
+	usedTime_ = usedTime;
+	setParameter("UsedTime", std::to_string(usedTime));
+}
+
+int CreateAndStartBackupPlanRequest::getSourceEndpointPort()const
+{
+	return sourceEndpointPort_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointPort(int sourceEndpointPort)
+{
+	sourceEndpointPort_ = sourceEndpointPort;
+	setParameter("SourceEndpointPort", std::to_string(sourceEndpointPort));
+}
+
+std::string CreateAndStartBackupPlanRequest::getStorageRegion()const
+{
+	return storageRegion_;
+}
+
+void CreateAndStartBackupPlanRequest::setStorageRegion(const std::string& storageRegion)
+{
+	storageRegion_ = storageRegion;
+	setParameter("StorageRegion", storageRegion);
+}
+
+std::string CreateAndStartBackupPlanRequest::getSourceEndpointOracleSID()const
+{
+	return sourceEndpointOracleSID_;
+}
+
+void CreateAndStartBackupPlanRequest::setSourceEndpointOracleSID(const std::string& sourceEndpointOracleSID)
+{
+	sourceEndpointOracleSID_ = sourceEndpointOracleSID;
+	setParameter("SourceEndpointOracleSID", sourceEndpointOracleSID);
+}
+
+std::string CreateAndStartBackupPlanRequest::getBackupStrategyType()const
+{
+	return backupStrategyType_;
+}
+
+void CreateAndStartBackupPlanRequest::setBackupStrategyType(const std::string& backupStrategyType)
+{
+	backupStrategyType_ = backupStrategyType;
+	setParameter("BackupStrategyType", backupStrategyType);
+}
+
+std::string CreateAndStartBackupPlanRequest::getPayType()const
+{
+	return payType_;
+}
+
+void CreateAndStartBackupPlanRequest::setPayType(const std::string& payType)
+{
+	payType_ = payType;
+	setParameter("PayType", payType);
+}
+

dbs/src/model/CreateAndStartBackupPlanResult.cc

@@ -0,0 +1,86 @@
+/*
+ * 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/dbs/model/CreateAndStartBackupPlanResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dbs;
+using namespace AlibabaCloud::Dbs::Model;
+
+CreateAndStartBackupPlanResult::CreateAndStartBackupPlanResult() :
+	ServiceResult()
+{}
+
+CreateAndStartBackupPlanResult::CreateAndStartBackupPlanResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateAndStartBackupPlanResult::~CreateAndStartBackupPlanResult()
+{}
+
+void CreateAndStartBackupPlanResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMessage"].isNull())
+		errMessage_ = value["ErrMessage"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["BackupPlanId"].isNull())
+		backupPlanId_ = value["BackupPlanId"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+int CreateAndStartBackupPlanResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string CreateAndStartBackupPlanResult::getBackupPlanId()const
+{
+	return backupPlanId_;
+}
+
+std::string CreateAndStartBackupPlanResult::getErrMessage()const
+{
+	return errMessage_;
+}
+
+std::string CreateAndStartBackupPlanResult::getOrderId()const
+{
+	return orderId_;
+}
+
+bool CreateAndStartBackupPlanResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string CreateAndStartBackupPlanResult::getErrCode()const
+{
+	return errCode_;
+}
+

dbs/src/model/CreateDLAServiceRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/dbs/model/CreateDLAServiceRequest.h>
+
+using AlibabaCloud::Dbs::Model::CreateDLAServiceRequest;
+
+CreateDLAServiceRequest::CreateDLAServiceRequest() :
+	RpcServiceRequest("dbs", "2019-03-06", "CreateDLAService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDLAServiceRequest::~CreateDLAServiceRequest()
+{}
+
+std::string CreateDLAServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateDLAServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+bool CreateDLAServiceRequest::getAutoAdd()const
+{
+	return autoAdd_;
+}
+
+void CreateDLAServiceRequest::setAutoAdd(bool autoAdd)
+{
+	autoAdd_ = autoAdd;
+	setParameter("AutoAdd", autoAdd ? "true" : "false");
+}
+
+std::string CreateDLAServiceRequest::getBackupSetIds()const
+{
+	return backupSetIds_;
+}
+
+void CreateDLAServiceRequest::setBackupSetIds(const std::string& backupSetIds)
+{
+	backupSetIds_ = backupSetIds;
+	setParameter("BackupSetIds", backupSetIds);
+}
+
+std::string CreateDLAServiceRequest::getBackupPlanId()const
+{
+	return backupPlanId_;
+}
+
+void CreateDLAServiceRequest::setBackupPlanId(const std::string& backupPlanId)
+{
+	backupPlanId_ = backupPlanId;
+	setParameter("BackupPlanId", backupPlanId);
+}
+
+std::string CreateDLAServiceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDLAServiceRequest::setOwnerId(const std::string& ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", ownerId);
+}
+

dbs/src/model/CreateDLAServiceResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/dbs/model/CreateDLAServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dbs;
+using namespace AlibabaCloud::Dbs::Model;
+
+CreateDLAServiceResult::CreateDLAServiceResult() :
+	ServiceResult()
+{}
+
+CreateDLAServiceResult::CreateDLAServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDLAServiceResult::~CreateDLAServiceResult()
+{}
+
+void CreateDLAServiceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMessage"].isNull())
+		errMessage_ = value["ErrMessage"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+
+}
+
+int CreateDLAServiceResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string CreateDLAServiceResult::getErrMessage()const
+{
+	return errMessage_;
+}
+
+bool CreateDLAServiceResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string CreateDLAServiceResult::getErrCode()const
+{
+	return errCode_;
+}
+

dbs/src/model/DescribeDLAServiceRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/dbs/model/DescribeDLAServiceRequest.h>
+
+using AlibabaCloud::Dbs::Model::DescribeDLAServiceRequest;
+
+DescribeDLAServiceRequest::DescribeDLAServiceRequest() :
+	RpcServiceRequest("dbs", "2019-03-06", "DescribeDLAService")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDLAServiceRequest::~DescribeDLAServiceRequest()
+{}
+
+std::string DescribeDLAServiceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DescribeDLAServiceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string DescribeDLAServiceRequest::getBackupPlanId()const
+{
+	return backupPlanId_;
+}
+
+void DescribeDLAServiceRequest::setBackupPlanId(const std::string& backupPlanId)
+{
+	backupPlanId_ = backupPlanId;
+	setParameter("BackupPlanId", backupPlanId);
+}
+
+std::string DescribeDLAServiceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDLAServiceRequest::setOwnerId(const std::string& ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", ownerId);
+}
+

dbs/src/model/DescribeDLAServiceResult.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/dbs/model/DescribeDLAServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dbs;
+using namespace AlibabaCloud::Dbs::Model;
+
+DescribeDLAServiceResult::DescribeDLAServiceResult() :
+	ServiceResult()
+{}
+
+DescribeDLAServiceResult::DescribeDLAServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDLAServiceResult::~DescribeDLAServiceResult()
+{}
+
+void DescribeDLAServiceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMessage"].isNull())
+		errMessage_ = value["ErrMessage"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["State"].isNull())
+		state_ = value["State"].asString();
+	if(!value["AutoAdd"].isNull())
+		autoAdd_ = value["AutoAdd"].asString() == "true";
+	if(!value["HaveJobFailed"].isNull())
+		haveJobFailed_ = value["HaveJobFailed"].asString() == "true";
+
+}
+
+bool DescribeDLAServiceResult::getAutoAdd()const
+{
+	return autoAdd_;
+}
+
+bool DescribeDLAServiceResult::getHaveJobFailed()const
+{
+	return haveJobFailed_;
+}
+
+std::string DescribeDLAServiceResult::getState()const
+{
+	return state_;
+}
+
+int DescribeDLAServiceResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string DescribeDLAServiceResult::getErrMessage()const
+{
+	return errMessage_;
+}
+
+bool DescribeDLAServiceResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string DescribeDLAServiceResult::getErrCode()const
+{
+	return errCode_;
+}
+