From 654af055e655537756b73527d4e576e342c9c693 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Fri, 12 Jun 2020 10:59:41 +0800 Subject: [PATCH] Add support for enable hbaseue extra module like lindorm-search or lindorm-sql. --- CHANGELOG | 3 + VERSION | 2 +- hbase/CMakeLists.txt | 4 + .../include/alibabacloud/hbase/HBaseClient.h | 8 + .../hbase/model/EnableHBaseueModuleRequest.h | 99 ++++++++ .../hbase/model/EnableHBaseueModuleResult.h | 53 ++++ hbase/src/HBaseClient.cc | 36 +++ hbase/src/model/EnableHBaseueModuleRequest.cc | 227 ++++++++++++++++++ hbase/src/model/EnableHBaseueModuleResult.cc | 58 +++++ 9 files changed, 489 insertions(+), 1 deletion(-) create mode 100644 hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h create mode 100644 hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h create mode 100644 hbase/src/model/EnableHBaseueModuleRequest.cc create mode 100644 hbase/src/model/EnableHBaseueModuleResult.cc diff --git a/CHANGELOG b/CHANGELOG index 303fc1532..0d34405a2 100644 --- a/CHANGELOG +++ b/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. diff --git a/VERSION b/VERSION index 1339221e2..a8af08f77 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.456 \ No newline at end of file +1.36.457 \ No newline at end of file diff --git a/hbase/CMakeLists.txt b/hbase/CMakeLists.txt index 4216cfc14..01c25665f 100644 --- a/hbase/CMakeLists.txt +++ b/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 diff --git a/hbase/include/alibabacloud/hbase/HBaseClient.h b/hbase/include/alibabacloud/hbase/HBaseClient.h index a86d5d103..a38f3f314 100644 --- a/hbase/include/alibabacloud/hbase/HBaseClient.h +++ b/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 EnableHBaseueBackupOutcome; typedef std::future EnableHBaseueBackupOutcomeCallable; typedef std::function&)> EnableHBaseueBackupAsyncHandler; + typedef Outcome EnableHBaseueModuleOutcome; + typedef std::future EnableHBaseueModuleOutcomeCallable; + typedef std::function&)> EnableHBaseueModuleAsyncHandler; typedef Outcome ListTagResourcesOutcome; typedef std::future ListTagResourcesOutcomeCallable; typedef std::function&)> 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& 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& 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& context = nullptr) const; ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const; diff --git a/hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h b/hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h new file mode 100644 index 000000000..fce88175e --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h b/hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h new file mode 100644 index 000000000..4a2404620 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/src/HBaseClient.cc b/hbase/src/HBaseClient.cc index cca0abd67..0e826e2a6 100644 --- a/hbase/src/HBaseClient.cc +++ b/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& 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>( + [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(); diff --git a/hbase/src/model/EnableHBaseueModuleRequest.cc b/hbase/src/model/EnableHBaseueModuleRequest.cc new file mode 100644 index 000000000..40208f0cd --- /dev/null +++ b/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 + +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); +} + diff --git a/hbase/src/model/EnableHBaseueModuleResult.cc b/hbase/src/model/EnableHBaseueModuleResult.cc new file mode 100644 index 000000000..1dc26f132 --- /dev/null +++ b/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 +#include + +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_; +} +