diff --git a/CHANGELOG b/CHANGELOG index f285cbbc5..94b8713bd 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-09-24 Version: patch +- Support create for serverlesshbase. + 2020-09-24 Version: patch - ContrastFaceVerify API Add Model Parameter. diff --git a/hbase/CMakeLists.txt b/hbase/CMakeLists.txt index bb2f54b3c..7207dfd67 100644 --- a/hbase/CMakeLists.txt +++ b/hbase/CMakeLists.txt @@ -35,6 +35,8 @@ set(hbase_public_header_model include/alibabacloud/hbase/model/CreateMultiZoneClusterResult.h include/alibabacloud/hbase/model/CreateRestorePlanRequest.h include/alibabacloud/hbase/model/CreateRestorePlanResult.h + include/alibabacloud/hbase/model/CreateServerlessClusterRequest.h + include/alibabacloud/hbase/model/CreateServerlessClusterResult.h include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h @@ -156,6 +158,8 @@ set(hbase_src src/model/CreateMultiZoneClusterResult.cc src/model/CreateRestorePlanRequest.cc src/model/CreateRestorePlanResult.cc + src/model/CreateServerlessClusterRequest.cc + src/model/CreateServerlessClusterResult.cc src/model/DeleteHBaseHaDBRequest.cc src/model/DeleteHBaseHaDBResult.cc src/model/DeleteHbaseHaSlbRequest.cc diff --git a/hbase/include/alibabacloud/hbase/HBaseClient.h b/hbase/include/alibabacloud/hbase/HBaseClient.h index 509e22e44..08b47441e 100644 --- a/hbase/include/alibabacloud/hbase/HBaseClient.h +++ b/hbase/include/alibabacloud/hbase/HBaseClient.h @@ -36,6 +36,8 @@ #include "model/CreateMultiZoneClusterResult.h" #include "model/CreateRestorePlanRequest.h" #include "model/CreateRestorePlanResult.h" +#include "model/CreateServerlessClusterRequest.h" +#include "model/CreateServerlessClusterResult.h" #include "model/DeleteHBaseHaDBRequest.h" #include "model/DeleteHBaseHaDBResult.h" #include "model/DeleteHbaseHaSlbRequest.h" @@ -170,6 +172,9 @@ namespace AlibabaCloud typedef Outcome CreateRestorePlanOutcome; typedef std::future CreateRestorePlanOutcomeCallable; typedef std::function&)> CreateRestorePlanAsyncHandler; + typedef Outcome CreateServerlessClusterOutcome; + typedef std::future CreateServerlessClusterOutcomeCallable; + typedef std::function&)> CreateServerlessClusterAsyncHandler; typedef Outcome DeleteHBaseHaDBOutcome; typedef std::future DeleteHBaseHaDBOutcomeCallable; typedef std::function&)> DeleteHBaseHaDBAsyncHandler; @@ -352,6 +357,9 @@ namespace AlibabaCloud CreateRestorePlanOutcome createRestorePlan(const Model::CreateRestorePlanRequest &request)const; void createRestorePlanAsync(const Model::CreateRestorePlanRequest& request, const CreateRestorePlanAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateRestorePlanOutcomeCallable createRestorePlanCallable(const Model::CreateRestorePlanRequest& request) const; + CreateServerlessClusterOutcome createServerlessCluster(const Model::CreateServerlessClusterRequest &request)const; + void createServerlessClusterAsync(const Model::CreateServerlessClusterRequest& request, const CreateServerlessClusterAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateServerlessClusterOutcomeCallable createServerlessClusterCallable(const Model::CreateServerlessClusterRequest& request) const; DeleteHBaseHaDBOutcome deleteHBaseHaDB(const Model::DeleteHBaseHaDBRequest &request)const; void deleteHBaseHaDBAsync(const Model::DeleteHBaseHaDBRequest& request, const DeleteHBaseHaDBAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DeleteHBaseHaDBOutcomeCallable deleteHBaseHaDBCallable(const Model::DeleteHBaseHaDBRequest& request) const; diff --git a/hbase/include/alibabacloud/hbase/model/CreateServerlessClusterRequest.h b/hbase/include/alibabacloud/hbase/model/CreateServerlessClusterRequest.h new file mode 100644 index 000000000..7ff3d2344 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/CreateServerlessClusterRequest.h @@ -0,0 +1,90 @@ +/* + * 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_CREATESERVERLESSCLUSTERREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_CREATESERVERLESSCLUSTERREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT CreateServerlessClusterRequest : public RpcServiceRequest + { + + public: + CreateServerlessClusterRequest(); + ~CreateServerlessClusterRequest(); + + std::string getClusterName()const; + void setClusterName(const std::string& clusterName); + std::string getClientToken()const; + void setClientToken(const std::string& clientToken); + std::string getEngineVersion()const; + void setEngineVersion(const std::string& engineVersion); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getEngine()const; + void setEngine(const std::string& engine); + int getAutoRenewPeriod()const; + void setAutoRenewPeriod(int autoRenewPeriod); + int getPeriod()const; + void setPeriod(int period); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getPeriodUnit()const; + void setPeriodUnit(const std::string& periodUnit); + int getServerlessCapability()const; + void setServerlessCapability(int serverlessCapability); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + std::string getZoneId()const; + void setZoneId(const std::string& zoneId); + int getServerlessStorage()const; + void setServerlessStorage(int serverlessStorage); + std::string getPayType()const; + void setPayType(const std::string& payType); + std::string getServerlessSpec()const; + void setServerlessSpec(const std::string& serverlessSpec); + + private: + std::string clusterName_; + std::string clientToken_; + std::string engineVersion_; + std::string regionId_; + std::string engine_; + int autoRenewPeriod_; + int period_; + std::string vSwitchId_; + std::string periodUnit_; + int serverlessCapability_; + std::string vpcId_; + std::string zoneId_; + int serverlessStorage_; + std::string payType_; + std::string serverlessSpec_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_CREATESERVERLESSCLUSTERREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/CreateServerlessClusterResult.h b/hbase/include/alibabacloud/hbase/model/CreateServerlessClusterResult.h new file mode 100644 index 000000000..81872e1c7 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/CreateServerlessClusterResult.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_CREATESERVERLESSCLUSTERRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_CREATESERVERLESSCLUSTERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT CreateServerlessClusterResult : public ServiceResult + { + public: + + + CreateServerlessClusterResult(); + explicit CreateServerlessClusterResult(const std::string &payload); + ~CreateServerlessClusterResult(); + 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_CREATESERVERLESSCLUSTERRESULT_H_ \ No newline at end of file diff --git a/hbase/src/HBaseClient.cc b/hbase/src/HBaseClient.cc index 56861dcc1..5ccd205f2 100644 --- a/hbase/src/HBaseClient.cc +++ b/hbase/src/HBaseClient.cc @@ -303,6 +303,42 @@ HBaseClient::CreateRestorePlanOutcomeCallable HBaseClient::createRestorePlanCall return task->get_future(); } +HBaseClient::CreateServerlessClusterOutcome HBaseClient::createServerlessCluster(const CreateServerlessClusterRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateServerlessClusterOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateServerlessClusterOutcome(CreateServerlessClusterResult(outcome.result())); + else + return CreateServerlessClusterOutcome(outcome.error()); +} + +void HBaseClient::createServerlessClusterAsync(const CreateServerlessClusterRequest& request, const CreateServerlessClusterAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createServerlessCluster(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::CreateServerlessClusterOutcomeCallable HBaseClient::createServerlessClusterCallable(const CreateServerlessClusterRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createServerlessCluster(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + HBaseClient::DeleteHBaseHaDBOutcome HBaseClient::deleteHBaseHaDB(const DeleteHBaseHaDBRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/hbase/src/model/CreateServerlessClusterRequest.cc b/hbase/src/model/CreateServerlessClusterRequest.cc new file mode 100644 index 000000000..02c6e4cbb --- /dev/null +++ b/hbase/src/model/CreateServerlessClusterRequest.cc @@ -0,0 +1,194 @@ +/* + * 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::CreateServerlessClusterRequest; + +CreateServerlessClusterRequest::CreateServerlessClusterRequest() : + RpcServiceRequest("hbase", "2019-01-01", "CreateServerlessCluster") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateServerlessClusterRequest::~CreateServerlessClusterRequest() +{} + +std::string CreateServerlessClusterRequest::getClusterName()const +{ + return clusterName_; +} + +void CreateServerlessClusterRequest::setClusterName(const std::string& clusterName) +{ + clusterName_ = clusterName; + setParameter("ClusterName", clusterName); +} + +std::string CreateServerlessClusterRequest::getClientToken()const +{ + return clientToken_; +} + +void CreateServerlessClusterRequest::setClientToken(const std::string& clientToken) +{ + clientToken_ = clientToken; + setParameter("ClientToken", clientToken); +} + +std::string CreateServerlessClusterRequest::getEngineVersion()const +{ + return engineVersion_; +} + +void CreateServerlessClusterRequest::setEngineVersion(const std::string& engineVersion) +{ + engineVersion_ = engineVersion; + setParameter("EngineVersion", engineVersion); +} + +std::string CreateServerlessClusterRequest::getRegionId()const +{ + return regionId_; +} + +void CreateServerlessClusterRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateServerlessClusterRequest::getEngine()const +{ + return engine_; +} + +void CreateServerlessClusterRequest::setEngine(const std::string& engine) +{ + engine_ = engine; + setParameter("Engine", engine); +} + +int CreateServerlessClusterRequest::getAutoRenewPeriod()const +{ + return autoRenewPeriod_; +} + +void CreateServerlessClusterRequest::setAutoRenewPeriod(int autoRenewPeriod) +{ + autoRenewPeriod_ = autoRenewPeriod; + setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod)); +} + +int CreateServerlessClusterRequest::getPeriod()const +{ + return period_; +} + +void CreateServerlessClusterRequest::setPeriod(int period) +{ + period_ = period; + setParameter("Period", std::to_string(period)); +} + +std::string CreateServerlessClusterRequest::getVSwitchId()const +{ + return vSwitchId_; +} + +void CreateServerlessClusterRequest::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; + setParameter("VSwitchId", vSwitchId); +} + +std::string CreateServerlessClusterRequest::getPeriodUnit()const +{ + return periodUnit_; +} + +void CreateServerlessClusterRequest::setPeriodUnit(const std::string& periodUnit) +{ + periodUnit_ = periodUnit; + setParameter("PeriodUnit", periodUnit); +} + +int CreateServerlessClusterRequest::getServerlessCapability()const +{ + return serverlessCapability_; +} + +void CreateServerlessClusterRequest::setServerlessCapability(int serverlessCapability) +{ + serverlessCapability_ = serverlessCapability; + setParameter("ServerlessCapability", std::to_string(serverlessCapability)); +} + +std::string CreateServerlessClusterRequest::getVpcId()const +{ + return vpcId_; +} + +void CreateServerlessClusterRequest::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; + setParameter("VpcId", vpcId); +} + +std::string CreateServerlessClusterRequest::getZoneId()const +{ + return zoneId_; +} + +void CreateServerlessClusterRequest::setZoneId(const std::string& zoneId) +{ + zoneId_ = zoneId; + setParameter("ZoneId", zoneId); +} + +int CreateServerlessClusterRequest::getServerlessStorage()const +{ + return serverlessStorage_; +} + +void CreateServerlessClusterRequest::setServerlessStorage(int serverlessStorage) +{ + serverlessStorage_ = serverlessStorage; + setParameter("ServerlessStorage", std::to_string(serverlessStorage)); +} + +std::string CreateServerlessClusterRequest::getPayType()const +{ + return payType_; +} + +void CreateServerlessClusterRequest::setPayType(const std::string& payType) +{ + payType_ = payType; + setParameter("PayType", payType); +} + +std::string CreateServerlessClusterRequest::getServerlessSpec()const +{ + return serverlessSpec_; +} + +void CreateServerlessClusterRequest::setServerlessSpec(const std::string& serverlessSpec) +{ + serverlessSpec_ = serverlessSpec; + setParameter("ServerlessSpec", serverlessSpec); +} + diff --git a/hbase/src/model/CreateServerlessClusterResult.cc b/hbase/src/model/CreateServerlessClusterResult.cc new file mode 100644 index 000000000..bfa910ec1 --- /dev/null +++ b/hbase/src/model/CreateServerlessClusterResult.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; + +CreateServerlessClusterResult::CreateServerlessClusterResult() : + ServiceResult() +{} + +CreateServerlessClusterResult::CreateServerlessClusterResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateServerlessClusterResult::~CreateServerlessClusterResult() +{} + +void CreateServerlessClusterResult::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 CreateServerlessClusterResult::getClusterId()const +{ + return clusterId_; +} + +std::string CreateServerlessClusterResult::getOrderId()const +{ + return orderId_; +} +