Add support for enable hbaseue extra module like lindorm-search or lindorm-sql.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-06-12 Version: 1.36.457
+- Add support for enable hbaseue extra module like lindorm-search or lindorm-sql.
+
 2020-06-11 Version: 1.36.456
 - Support ServicePeriodUnit in QueryInstanceBill.
 

VERSION

@@ -1 +1 @@
-1.36.456
+1.36.457

hbase/CMakeLists.txt

@@ -85,6 +85,8 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h
 	include/alibabacloud/hbase/model/EnableHBaseueBackupRequest.h
 	include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h
+	include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h
+	include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h
 	include/alibabacloud/hbase/model/ListTagResourcesRequest.h
 	include/alibabacloud/hbase/model/ListTagResourcesResult.h
 	include/alibabacloud/hbase/model/ListTagsRequest.h
@@ -192,6 +194,8 @@ set(hbase_src
 	src/model/DescribeSecurityGroupsResult.cc
 	src/model/EnableHBaseueBackupRequest.cc
 	src/model/EnableHBaseueBackupResult.cc
+	src/model/EnableHBaseueModuleRequest.cc
+	src/model/EnableHBaseueModuleResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
 	src/model/ListTagsRequest.cc

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -86,6 +86,8 @@
 #include "model/DescribeSecurityGroupsResult.h"
 #include "model/EnableHBaseueBackupRequest.h"
 #include "model/EnableHBaseueBackupResult.h"
+#include "model/EnableHBaseueModuleRequest.h"
+#include "model/EnableHBaseueModuleResult.h"
 #include "model/ListTagResourcesRequest.h"
 #include "model/ListTagResourcesResult.h"
 #include "model/ListTagsRequest.h"
@@ -231,6 +233,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EnableHBaseueBackupResult> EnableHBaseueBackupOutcome;
 			typedef std::future<EnableHBaseueBackupOutcome> EnableHBaseueBackupOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::EnableHBaseueBackupRequest&, const EnableHBaseueBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHBaseueBackupAsyncHandler;
+			typedef Outcome<Error, Model::EnableHBaseueModuleResult> EnableHBaseueModuleOutcome;
+			typedef std::future<EnableHBaseueModuleOutcome> EnableHBaseueModuleOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::EnableHBaseueModuleRequest&, const EnableHBaseueModuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHBaseueModuleAsyncHandler;
 			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
 			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
@@ -392,6 +397,9 @@ namespace AlibabaCloud
 			EnableHBaseueBackupOutcome enableHBaseueBackup(const Model::EnableHBaseueBackupRequest &request)const;
 			void enableHBaseueBackupAsync(const Model::EnableHBaseueBackupRequest& request, const EnableHBaseueBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableHBaseueBackupOutcomeCallable enableHBaseueBackupCallable(const Model::EnableHBaseueBackupRequest& request) const;
+			EnableHBaseueModuleOutcome enableHBaseueModule(const Model::EnableHBaseueModuleRequest &request)const;
+			void enableHBaseueModuleAsync(const Model::EnableHBaseueModuleRequest& request, const EnableHBaseueModuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableHBaseueModuleOutcomeCallable enableHBaseueModuleCallable(const Model::EnableHBaseueModuleRequest& request) const;
 			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
 			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;

hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h

@@ -0,0 +1,99 @@
+/*
+ * 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_HBASE_MODEL_ENABLEHBASEUEMODULEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT EnableHBaseueModuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnableHBaseueModuleRequest();
+				~EnableHBaseueModuleRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getModuleTypeName()const;
+				void setModuleTypeName(const std::string& moduleTypeName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getHbaseueClusterId()const;
+				void setHbaseueClusterId(const std::string& hbaseueClusterId);
+				std::string getBdsId()const;
+				void setBdsId(const std::string& bdsId);
+				std::string getModuleClusterName()const;
+				void setModuleClusterName(const std::string& moduleClusterName);
+				int getAutoRenewPeriod()const;
+				void setAutoRenewPeriod(int autoRenewPeriod);
+				int getPeriod()const;
+				void setPeriod(int period);
+				int getDiskSize()const;
+				void setDiskSize(int diskSize);
+				std::string getMasterInstanceType()const;
+				void setMasterInstanceType(const std::string& masterInstanceType);
+				std::string getDiskType()const;
+				void setDiskType(const std::string& diskType);
+				std::string getVswitchId()const;
+				void setVswitchId(const std::string& vswitchId);
+				std::string getPeriodUnit()const;
+				void setPeriodUnit(const std::string& periodUnit);
+				std::string getCoreInstanceType()const;
+				void setCoreInstanceType(const std::string& coreInstanceType);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				int getNodeCount()const;
+				void setNodeCount(int nodeCount);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getPayType()const;
+				void setPayType(const std::string& payType);
+
+            private:
+				std::string clientToken_;
+				std::string moduleTypeName_;
+				std::string regionId_;
+				std::string hbaseueClusterId_;
+				std::string bdsId_;
+				std::string moduleClusterName_;
+				int autoRenewPeriod_;
+				int period_;
+				int diskSize_;
+				std::string masterInstanceType_;
+				std::string diskType_;
+				std::string vswitchId_;
+				std::string periodUnit_;
+				std::string coreInstanceType_;
+				std::string vpcId_;
+				int nodeCount_;
+				std::string zoneId_;
+				std::string payType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULEREQUEST_H_

hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_HBASE_MODEL_ENABLEHBASEUEMODULERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT EnableHBaseueModuleResult : public ServiceResult
+			{
+			public:
+
+
+				EnableHBaseueModuleResult();
+				explicit EnableHBaseueModuleResult(const std::string &payload);
+				~EnableHBaseueModuleResult();
+				std::string getClusterId()const;
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clusterId_;
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULERESULT_H_

hbase/src/HBaseClient.cc

@@ -1203,6 +1203,42 @@ HBaseClient::EnableHBaseueBackupOutcomeCallable HBaseClient::enableHBaseueBackup
 	return task->get_future();
 }
 
+HBaseClient::EnableHBaseueModuleOutcome HBaseClient::enableHBaseueModule(const EnableHBaseueModuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableHBaseueModuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableHBaseueModuleOutcome(EnableHBaseueModuleResult(outcome.result()));
+	else
+		return EnableHBaseueModuleOutcome(outcome.error());
+}
+
+void HBaseClient::enableHBaseueModuleAsync(const EnableHBaseueModuleRequest& request, const EnableHBaseueModuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableHBaseueModule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::EnableHBaseueModuleOutcomeCallable HBaseClient::enableHBaseueModuleCallable(const EnableHBaseueModuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableHBaseueModuleOutcome()>>(
+			[this, request]()
+			{
+			return this->enableHBaseueModule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hbase/src/model/EnableHBaseueModuleRequest.cc

@@ -0,0 +1,227 @@
+/*
+ * 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/hbase/model/EnableHBaseueModuleRequest.h>
+
+using AlibabaCloud::HBase::Model::EnableHBaseueModuleRequest;
+
+EnableHBaseueModuleRequest::EnableHBaseueModuleRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "EnableHBaseueModule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnableHBaseueModuleRequest::~EnableHBaseueModuleRequest()
+{}
+
+std::string EnableHBaseueModuleRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void EnableHBaseueModuleRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string EnableHBaseueModuleRequest::getModuleTypeName()const
+{
+	return moduleTypeName_;
+}
+
+void EnableHBaseueModuleRequest::setModuleTypeName(const std::string& moduleTypeName)
+{
+	moduleTypeName_ = moduleTypeName;
+	setParameter("ModuleTypeName", moduleTypeName);
+}
+
+std::string EnableHBaseueModuleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void EnableHBaseueModuleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string EnableHBaseueModuleRequest::getHbaseueClusterId()const
+{
+	return hbaseueClusterId_;
+}
+
+void EnableHBaseueModuleRequest::setHbaseueClusterId(const std::string& hbaseueClusterId)
+{
+	hbaseueClusterId_ = hbaseueClusterId;
+	setParameter("HbaseueClusterId", hbaseueClusterId);
+}
+
+std::string EnableHBaseueModuleRequest::getBdsId()const
+{
+	return bdsId_;
+}
+
+void EnableHBaseueModuleRequest::setBdsId(const std::string& bdsId)
+{
+	bdsId_ = bdsId;
+	setParameter("BdsId", bdsId);
+}
+
+std::string EnableHBaseueModuleRequest::getModuleClusterName()const
+{
+	return moduleClusterName_;
+}
+
+void EnableHBaseueModuleRequest::setModuleClusterName(const std::string& moduleClusterName)
+{
+	moduleClusterName_ = moduleClusterName;
+	setParameter("ModuleClusterName", moduleClusterName);
+}
+
+int EnableHBaseueModuleRequest::getAutoRenewPeriod()const
+{
+	return autoRenewPeriod_;
+}
+
+void EnableHBaseueModuleRequest::setAutoRenewPeriod(int autoRenewPeriod)
+{
+	autoRenewPeriod_ = autoRenewPeriod;
+	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+}
+
+int EnableHBaseueModuleRequest::getPeriod()const
+{
+	return period_;
+}
+
+void EnableHBaseueModuleRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+int EnableHBaseueModuleRequest::getDiskSize()const
+{
+	return diskSize_;
+}
+
+void EnableHBaseueModuleRequest::setDiskSize(int diskSize)
+{
+	diskSize_ = diskSize;
+	setParameter("DiskSize", std::to_string(diskSize));
+}
+
+std::string EnableHBaseueModuleRequest::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+void EnableHBaseueModuleRequest::setMasterInstanceType(const std::string& masterInstanceType)
+{
+	masterInstanceType_ = masterInstanceType;
+	setParameter("MasterInstanceType", masterInstanceType);
+}
+
+std::string EnableHBaseueModuleRequest::getDiskType()const
+{
+	return diskType_;
+}
+
+void EnableHBaseueModuleRequest::setDiskType(const std::string& diskType)
+{
+	diskType_ = diskType;
+	setParameter("DiskType", diskType);
+}
+
+std::string EnableHBaseueModuleRequest::getVswitchId()const
+{
+	return vswitchId_;
+}
+
+void EnableHBaseueModuleRequest::setVswitchId(const std::string& vswitchId)
+{
+	vswitchId_ = vswitchId;
+	setParameter("VswitchId", vswitchId);
+}
+
+std::string EnableHBaseueModuleRequest::getPeriodUnit()const
+{
+	return periodUnit_;
+}
+
+void EnableHBaseueModuleRequest::setPeriodUnit(const std::string& periodUnit)
+{
+	periodUnit_ = periodUnit;
+	setParameter("PeriodUnit", periodUnit);
+}
+
+std::string EnableHBaseueModuleRequest::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+void EnableHBaseueModuleRequest::setCoreInstanceType(const std::string& coreInstanceType)
+{
+	coreInstanceType_ = coreInstanceType;
+	setParameter("CoreInstanceType", coreInstanceType);
+}
+
+std::string EnableHBaseueModuleRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void EnableHBaseueModuleRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+int EnableHBaseueModuleRequest::getNodeCount()const
+{
+	return nodeCount_;
+}
+
+void EnableHBaseueModuleRequest::setNodeCount(int nodeCount)
+{
+	nodeCount_ = nodeCount;
+	setParameter("NodeCount", std::to_string(nodeCount));
+}
+
+std::string EnableHBaseueModuleRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void EnableHBaseueModuleRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string EnableHBaseueModuleRequest::getPayType()const
+{
+	return payType_;
+}
+
+void EnableHBaseueModuleRequest::setPayType(const std::string& payType)
+{
+	payType_ = payType;
+	setParameter("PayType", payType);
+}
+

hbase/src/model/EnableHBaseueModuleResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/hbase/model/EnableHBaseueModuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+EnableHBaseueModuleResult::EnableHBaseueModuleResult() :
+	ServiceResult()
+{}
+
+EnableHBaseueModuleResult::EnableHBaseueModuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnableHBaseueModuleResult::~EnableHBaseueModuleResult()
+{}
+
+void EnableHBaseueModuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+std::string EnableHBaseueModuleResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::string EnableHBaseueModuleResult::getOrderId()const
+{
+	return orderId_;
+}
+