Support DryRunCluster For LakeVersion.

adb/CMakeLists.txt

@@ -169,6 +169,8 @@ set(adb_public_header_model
 	include/alibabacloud/adb/model/DisableAdviceServiceResult.h
 	include/alibabacloud/adb/model/DownloadDiagnosisRecordsRequest.h
 	include/alibabacloud/adb/model/DownloadDiagnosisRecordsResult.h
+	include/alibabacloud/adb/model/DryRunClusterRequest.h
+	include/alibabacloud/adb/model/DryRunClusterResult.h
 	include/alibabacloud/adb/model/EnableAdviceServiceRequest.h
 	include/alibabacloud/adb/model/EnableAdviceServiceResult.h
 	include/alibabacloud/adb/model/GrantOperatorPermissionRequest.h
@@ -374,6 +376,8 @@ set(adb_src
 	src/model/DisableAdviceServiceResult.cc
 	src/model/DownloadDiagnosisRecordsRequest.cc
 	src/model/DownloadDiagnosisRecordsResult.cc
+	src/model/DryRunClusterRequest.cc
+	src/model/DryRunClusterResult.cc
 	src/model/EnableAdviceServiceRequest.cc
 	src/model/EnableAdviceServiceResult.cc
 	src/model/GrantOperatorPermissionRequest.cc

adb/include/alibabacloud/adb/AdbClient.h

@@ -170,6 +170,8 @@
 #include "model/DisableAdviceServiceResult.h"
 #include "model/DownloadDiagnosisRecordsRequest.h"
 #include "model/DownloadDiagnosisRecordsResult.h"
+#include "model/DryRunClusterRequest.h"
+#include "model/DryRunClusterResult.h"
 #include "model/EnableAdviceServiceRequest.h"
 #include "model/EnableAdviceServiceResult.h"
 #include "model/GrantOperatorPermissionRequest.h"
@@ -455,6 +457,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DownloadDiagnosisRecordsResult> DownloadDiagnosisRecordsOutcome;
 			typedef std::future<DownloadDiagnosisRecordsOutcome> DownloadDiagnosisRecordsOutcomeCallable;
 			typedef std::function<void(const AdbClient*, const Model::DownloadDiagnosisRecordsRequest&, const DownloadDiagnosisRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DownloadDiagnosisRecordsAsyncHandler;
+			typedef Outcome<Error, Model::DryRunClusterResult> DryRunClusterOutcome;
+			typedef std::future<DryRunClusterOutcome> DryRunClusterOutcomeCallable;
+			typedef std::function<void(const AdbClient*, const Model::DryRunClusterRequest&, const DryRunClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DryRunClusterAsyncHandler;
 			typedef Outcome<Error, Model::EnableAdviceServiceResult> EnableAdviceServiceOutcome;
 			typedef std::future<EnableAdviceServiceOutcome> EnableAdviceServiceOutcomeCallable;
 			typedef std::function<void(const AdbClient*, const Model::EnableAdviceServiceRequest&, const EnableAdviceServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAdviceServiceAsyncHandler;
@@ -763,6 +768,9 @@ namespace AlibabaCloud
 			DownloadDiagnosisRecordsOutcome downloadDiagnosisRecords(const Model::DownloadDiagnosisRecordsRequest &request)const;
 			void downloadDiagnosisRecordsAsync(const Model::DownloadDiagnosisRecordsRequest& request, const DownloadDiagnosisRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DownloadDiagnosisRecordsOutcomeCallable downloadDiagnosisRecordsCallable(const Model::DownloadDiagnosisRecordsRequest& request) const;
+			DryRunClusterOutcome dryRunCluster(const Model::DryRunClusterRequest &request)const;
+			void dryRunClusterAsync(const Model::DryRunClusterRequest& request, const DryRunClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DryRunClusterOutcomeCallable dryRunClusterCallable(const Model::DryRunClusterRequest& request) const;
 			EnableAdviceServiceOutcome enableAdviceService(const Model::EnableAdviceServiceRequest &request)const;
 			void enableAdviceServiceAsync(const Model::EnableAdviceServiceRequest& request, const EnableAdviceServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableAdviceServiceOutcomeCallable enableAdviceServiceCallable(const Model::EnableAdviceServiceRequest& request) const;

adb/include/alibabacloud/adb/model/DryRunClusterRequest.h

@@ -0,0 +1,87 @@
+/*
+ * 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_ADB_MODEL_DRYRUNCLUSTERREQUEST_H_
+#define ALIBABACLOUD_ADB_MODEL_DRYRUNCLUSTERREQUEST_H_
+
+#include <alibabacloud/adb/AdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Adb {
+namespace Model {
+class ALIBABACLOUD_ADB_EXPORT DryRunClusterRequest : public RpcServiceRequest {
+public:
+	DryRunClusterRequest();
+	~DryRunClusterRequest();
+	std::string getDBClusterDescription() const;
+	void setDBClusterDescription(const std::string &dBClusterDescription);
+	bool getEnableDefaultResourcePool() const;
+	void setEnableDefaultResourcePool(bool enableDefaultResourcePool);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getStorageResource() const;
+	void setStorageResource(const std::string &storageResource);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBClusterNetworkType() const;
+	void setDBClusterNetworkType(const std::string &dBClusterNetworkType);
+	std::string getPeriod() const;
+	void setPeriod(const std::string &period);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getDBClusterVersion() const;
+	void setDBClusterVersion(const std::string &dBClusterVersion);
+	std::string getUsedTime() const;
+	void setUsedTime(const std::string &usedTime);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getVPCId() const;
+	void setVPCId(const std::string &vPCId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getComputeResource() const;
+	void setComputeResource(const std::string &computeResource);
+	std::string getPayType() const;
+	void setPayType(const std::string &payType);
+	std::string getOperation() const;
+	void setOperation(const std::string &operation);
+
+private:
+	std::string dBClusterDescription_;
+	bool enableDefaultResourcePool_;
+	std::string accessKeyId_;
+	std::string storageResource_;
+	std::string regionId_;
+	std::string dBClusterNetworkType_;
+	std::string period_;
+	std::string dBClusterId_;
+	std::string dBClusterVersion_;
+	std::string usedTime_;
+	std::string vSwitchId_;
+	std::string vPCId_;
+	std::string zoneId_;
+	std::string computeResource_;
+	std::string payType_;
+	std::string operation_;
+};
+} // namespace Model
+} // namespace Adb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ADB_MODEL_DRYRUNCLUSTERREQUEST_H_

adb/include/alibabacloud/adb/model/DryRunClusterResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_ADB_MODEL_DRYRUNCLUSTERRESULT_H_
+#define ALIBABACLOUD_ADB_MODEL_DRYRUNCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/adb/AdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Adb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADB_EXPORT DryRunClusterResult : public ServiceResult
+			{
+			public:
+
+
+				DryRunClusterResult();
+				explicit DryRunClusterResult(const std::string &payload);
+				~DryRunClusterResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADB_MODEL_DRYRUNCLUSTERRESULT_H_

adb/src/AdbClient.cc

@@ -2715,6 +2715,42 @@ AdbClient::DownloadDiagnosisRecordsOutcomeCallable AdbClient::downloadDiagnosisR
 	return task->get_future();
 }
 
+AdbClient::DryRunClusterOutcome AdbClient::dryRunCluster(const DryRunClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DryRunClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DryRunClusterOutcome(DryRunClusterResult(outcome.result()));
+	else
+		return DryRunClusterOutcome(outcome.error());
+}
+
+void AdbClient::dryRunClusterAsync(const DryRunClusterRequest& request, const DryRunClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, dryRunCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DryRunClusterOutcomeCallable AdbClient::dryRunClusterCallable(const DryRunClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DryRunClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->dryRunCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::EnableAdviceServiceOutcome AdbClient::enableAdviceService(const EnableAdviceServiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

adb/src/model/DryRunClusterRequest.cc

@@ -0,0 +1,171 @@
+/*
+ * 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/adb/model/DryRunClusterRequest.h>
+
+using AlibabaCloud::Adb::Model::DryRunClusterRequest;
+
+DryRunClusterRequest::DryRunClusterRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DryRunCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DryRunClusterRequest::~DryRunClusterRequest() {}
+
+std::string DryRunClusterRequest::getDBClusterDescription() const {
+  return dBClusterDescription_;
+}
+
+void DryRunClusterRequest::setDBClusterDescription(const std::string &dBClusterDescription) {
+  dBClusterDescription_ = dBClusterDescription;
+  setParameter(std::string("DBClusterDescription"), dBClusterDescription);
+}
+
+bool DryRunClusterRequest::getEnableDefaultResourcePool() const {
+  return enableDefaultResourcePool_;
+}
+
+void DryRunClusterRequest::setEnableDefaultResourcePool(bool enableDefaultResourcePool) {
+  enableDefaultResourcePool_ = enableDefaultResourcePool;
+  setParameter(std::string("EnableDefaultResourcePool"), enableDefaultResourcePool ? "true" : "false");
+}
+
+std::string DryRunClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DryRunClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DryRunClusterRequest::getStorageResource() const {
+  return storageResource_;
+}
+
+void DryRunClusterRequest::setStorageResource(const std::string &storageResource) {
+  storageResource_ = storageResource;
+  setParameter(std::string("StorageResource"), storageResource);
+}
+
+std::string DryRunClusterRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DryRunClusterRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DryRunClusterRequest::getDBClusterNetworkType() const {
+  return dBClusterNetworkType_;
+}
+
+void DryRunClusterRequest::setDBClusterNetworkType(const std::string &dBClusterNetworkType) {
+  dBClusterNetworkType_ = dBClusterNetworkType;
+  setParameter(std::string("DBClusterNetworkType"), dBClusterNetworkType);
+}
+
+std::string DryRunClusterRequest::getPeriod() const {
+  return period_;
+}
+
+void DryRunClusterRequest::setPeriod(const std::string &period) {
+  period_ = period;
+  setParameter(std::string("Period"), period);
+}
+
+std::string DryRunClusterRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DryRunClusterRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DryRunClusterRequest::getDBClusterVersion() const {
+  return dBClusterVersion_;
+}
+
+void DryRunClusterRequest::setDBClusterVersion(const std::string &dBClusterVersion) {
+  dBClusterVersion_ = dBClusterVersion;
+  setParameter(std::string("DBClusterVersion"), dBClusterVersion);
+}
+
+std::string DryRunClusterRequest::getUsedTime() const {
+  return usedTime_;
+}
+
+void DryRunClusterRequest::setUsedTime(const std::string &usedTime) {
+  usedTime_ = usedTime;
+  setParameter(std::string("UsedTime"), usedTime);
+}
+
+std::string DryRunClusterRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void DryRunClusterRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string DryRunClusterRequest::getVPCId() const {
+  return vPCId_;
+}
+
+void DryRunClusterRequest::setVPCId(const std::string &vPCId) {
+  vPCId_ = vPCId;
+  setParameter(std::string("VPCId"), vPCId);
+}
+
+std::string DryRunClusterRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void DryRunClusterRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+std::string DryRunClusterRequest::getComputeResource() const {
+  return computeResource_;
+}
+
+void DryRunClusterRequest::setComputeResource(const std::string &computeResource) {
+  computeResource_ = computeResource;
+  setParameter(std::string("ComputeResource"), computeResource);
+}
+
+std::string DryRunClusterRequest::getPayType() const {
+  return payType_;
+}
+
+void DryRunClusterRequest::setPayType(const std::string &payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), payType);
+}
+
+std::string DryRunClusterRequest::getOperation() const {
+  return operation_;
+}
+
+void DryRunClusterRequest::setOperation(const std::string &operation) {
+  operation_ = operation;
+  setParameter(std::string("Operation"), operation);
+}
+

adb/src/model/DryRunClusterResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/adb/model/DryRunClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DryRunClusterResult::DryRunClusterResult() :
+	ServiceResult()
+{}
+
+DryRunClusterResult::DryRunClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DryRunClusterResult::~DryRunClusterResult()
+{}
+
+void DryRunClusterResult::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";
+
+}
+
+bool DryRunClusterResult::getSuccess()const
+{
+	return success_;
+}
+