diff --git a/CHANGELOG b/CHANGELOG index 1e2b4fb3e..8dd4cfb64 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-09-28 Version: patch +- Support for resize hbaseue multi-zone cluster. + 2020-09-28 Version: patch - Support filtering keys and secrets. - Support opening KMS service and describing service status by API. diff --git a/hbase/CMakeLists.txt b/hbase/CMakeLists.txt index 7207dfd67..85ef31275 100644 --- a/hbase/CMakeLists.txt +++ b/hbase/CMakeLists.txt @@ -113,6 +113,8 @@ set(hbase_public_header_model include/alibabacloud/hbase/model/ModifyInstanceNameResult.h include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h include/alibabacloud/hbase/model/ModifyIpWhitelistResult.h + include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h + include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.h include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.h include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h @@ -127,6 +129,10 @@ set(hbase_public_header_model include/alibabacloud/hbase/model/RenewInstanceResult.h include/alibabacloud/hbase/model/ResizeDiskSizeRequest.h include/alibabacloud/hbase/model/ResizeDiskSizeResult.h + include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.h + include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.h + include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h + include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.h include/alibabacloud/hbase/model/ResizeNodeCountRequest.h include/alibabacloud/hbase/model/ResizeNodeCountResult.h include/alibabacloud/hbase/model/RestartInstanceRequest.h @@ -236,6 +242,8 @@ set(hbase_src src/model/ModifyInstanceNameResult.cc src/model/ModifyIpWhitelistRequest.cc src/model/ModifyIpWhitelistResult.cc + src/model/ModifyMultiZoneClusterNodeTypeRequest.cc + src/model/ModifyMultiZoneClusterNodeTypeResult.cc src/model/ModifySecurityGroupsRequest.cc src/model/ModifySecurityGroupsResult.cc src/model/ModifyUIAccountPasswordRequest.cc @@ -250,6 +258,10 @@ set(hbase_src src/model/RenewInstanceResult.cc src/model/ResizeDiskSizeRequest.cc src/model/ResizeDiskSizeResult.cc + src/model/ResizeMultiZoneClusterDiskSizeRequest.cc + src/model/ResizeMultiZoneClusterDiskSizeResult.cc + src/model/ResizeMultiZoneClusterNodeCountRequest.cc + src/model/ResizeMultiZoneClusterNodeCountResult.cc src/model/ResizeNodeCountRequest.cc src/model/ResizeNodeCountResult.cc src/model/RestartInstanceRequest.cc diff --git a/hbase/include/alibabacloud/hbase/HBaseClient.h b/hbase/include/alibabacloud/hbase/HBaseClient.h index 08b47441e..86416babf 100644 --- a/hbase/include/alibabacloud/hbase/HBaseClient.h +++ b/hbase/include/alibabacloud/hbase/HBaseClient.h @@ -114,6 +114,8 @@ #include "model/ModifyInstanceNameResult.h" #include "model/ModifyIpWhitelistRequest.h" #include "model/ModifyIpWhitelistResult.h" +#include "model/ModifyMultiZoneClusterNodeTypeRequest.h" +#include "model/ModifyMultiZoneClusterNodeTypeResult.h" #include "model/ModifySecurityGroupsRequest.h" #include "model/ModifySecurityGroupsResult.h" #include "model/ModifyUIAccountPasswordRequest.h" @@ -128,6 +130,10 @@ #include "model/RenewInstanceResult.h" #include "model/ResizeDiskSizeRequest.h" #include "model/ResizeDiskSizeResult.h" +#include "model/ResizeMultiZoneClusterDiskSizeRequest.h" +#include "model/ResizeMultiZoneClusterDiskSizeResult.h" +#include "model/ResizeMultiZoneClusterNodeCountRequest.h" +#include "model/ResizeMultiZoneClusterNodeCountResult.h" #include "model/ResizeNodeCountRequest.h" #include "model/ResizeNodeCountResult.h" #include "model/RestartInstanceRequest.h" @@ -289,6 +295,9 @@ namespace AlibabaCloud typedef Outcome ModifyIpWhitelistOutcome; typedef std::future ModifyIpWhitelistOutcomeCallable; typedef std::function&)> ModifyIpWhitelistAsyncHandler; + typedef Outcome ModifyMultiZoneClusterNodeTypeOutcome; + typedef std::future ModifyMultiZoneClusterNodeTypeOutcomeCallable; + typedef std::function&)> ModifyMultiZoneClusterNodeTypeAsyncHandler; typedef Outcome ModifySecurityGroupsOutcome; typedef std::future ModifySecurityGroupsOutcomeCallable; typedef std::function&)> ModifySecurityGroupsAsyncHandler; @@ -310,6 +319,12 @@ namespace AlibabaCloud typedef Outcome ResizeDiskSizeOutcome; typedef std::future ResizeDiskSizeOutcomeCallable; typedef std::function&)> ResizeDiskSizeAsyncHandler; + typedef Outcome ResizeMultiZoneClusterDiskSizeOutcome; + typedef std::future ResizeMultiZoneClusterDiskSizeOutcomeCallable; + typedef std::function&)> ResizeMultiZoneClusterDiskSizeAsyncHandler; + typedef Outcome ResizeMultiZoneClusterNodeCountOutcome; + typedef std::future ResizeMultiZoneClusterNodeCountOutcomeCallable; + typedef std::function&)> ResizeMultiZoneClusterNodeCountAsyncHandler; typedef Outcome ResizeNodeCountOutcome; typedef std::future ResizeNodeCountOutcomeCallable; typedef std::function&)> ResizeNodeCountAsyncHandler; @@ -474,6 +489,9 @@ namespace AlibabaCloud ModifyIpWhitelistOutcome modifyIpWhitelist(const Model::ModifyIpWhitelistRequest &request)const; void modifyIpWhitelistAsync(const Model::ModifyIpWhitelistRequest& request, const ModifyIpWhitelistAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyIpWhitelistOutcomeCallable modifyIpWhitelistCallable(const Model::ModifyIpWhitelistRequest& request) const; + ModifyMultiZoneClusterNodeTypeOutcome modifyMultiZoneClusterNodeType(const Model::ModifyMultiZoneClusterNodeTypeRequest &request)const; + void modifyMultiZoneClusterNodeTypeAsync(const Model::ModifyMultiZoneClusterNodeTypeRequest& request, const ModifyMultiZoneClusterNodeTypeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyMultiZoneClusterNodeTypeOutcomeCallable modifyMultiZoneClusterNodeTypeCallable(const Model::ModifyMultiZoneClusterNodeTypeRequest& request) const; ModifySecurityGroupsOutcome modifySecurityGroups(const Model::ModifySecurityGroupsRequest &request)const; void modifySecurityGroupsAsync(const Model::ModifySecurityGroupsRequest& request, const ModifySecurityGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifySecurityGroupsOutcomeCallable modifySecurityGroupsCallable(const Model::ModifySecurityGroupsRequest& request) const; @@ -495,6 +513,12 @@ namespace AlibabaCloud ResizeDiskSizeOutcome resizeDiskSize(const Model::ResizeDiskSizeRequest &request)const; void resizeDiskSizeAsync(const Model::ResizeDiskSizeRequest& request, const ResizeDiskSizeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ResizeDiskSizeOutcomeCallable resizeDiskSizeCallable(const Model::ResizeDiskSizeRequest& request) const; + ResizeMultiZoneClusterDiskSizeOutcome resizeMultiZoneClusterDiskSize(const Model::ResizeMultiZoneClusterDiskSizeRequest &request)const; + void resizeMultiZoneClusterDiskSizeAsync(const Model::ResizeMultiZoneClusterDiskSizeRequest& request, const ResizeMultiZoneClusterDiskSizeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ResizeMultiZoneClusterDiskSizeOutcomeCallable resizeMultiZoneClusterDiskSizeCallable(const Model::ResizeMultiZoneClusterDiskSizeRequest& request) const; + ResizeMultiZoneClusterNodeCountOutcome resizeMultiZoneClusterNodeCount(const Model::ResizeMultiZoneClusterNodeCountRequest &request)const; + void resizeMultiZoneClusterNodeCountAsync(const Model::ResizeMultiZoneClusterNodeCountRequest& request, const ResizeMultiZoneClusterNodeCountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ResizeMultiZoneClusterNodeCountOutcomeCallable resizeMultiZoneClusterNodeCountCallable(const Model::ResizeMultiZoneClusterNodeCountRequest& request) const; ResizeNodeCountOutcome resizeNodeCount(const Model::ResizeNodeCountRequest &request)const; void resizeNodeCountAsync(const Model::ResizeNodeCountRequest& request, const ResizeNodeCountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ResizeNodeCountOutcomeCallable resizeNodeCountCallable(const Model::ResizeNodeCountRequest& request) const; diff --git a/hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h b/hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h new file mode 100644 index 000000000..ad00bc2b3 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.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_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyMultiZoneClusterNodeTypeRequest : public RpcServiceRequest + { + + public: + ModifyMultiZoneClusterNodeTypeRequest(); + ~ModifyMultiZoneClusterNodeTypeRequest(); + + std::string getLogInstanceType()const; + void setLogInstanceType(const std::string& logInstanceType); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getMasterInstanceType()const; + void setMasterInstanceType(const std::string& masterInstanceType); + std::string getCoreInstanceType()const; + void setCoreInstanceType(const std::string& coreInstanceType); + + private: + std::string logInstanceType_; + std::string clusterId_; + std::string masterInstanceType_; + std::string coreInstanceType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.h b/hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.h new file mode 100644 index 000000000..2946f199a --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.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_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyMultiZoneClusterNodeTypeResult : public ServiceResult + { + public: + + + ModifyMultiZoneClusterNodeTypeResult(); + explicit ModifyMultiZoneClusterNodeTypeResult(const std::string &payload); + ~ModifyMultiZoneClusterNodeTypeResult(); + std::string getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + std::string orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYMULTIZONECLUSTERNODETYPERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.h b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.h new file mode 100644 index 000000000..a972ad31d --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.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_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeMultiZoneClusterDiskSizeRequest : public RpcServiceRequest + { + + public: + ResizeMultiZoneClusterDiskSizeRequest(); + ~ResizeMultiZoneClusterDiskSizeRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getLogDiskSize()const; + void setLogDiskSize(int logDiskSize); + int getCoreDiskSize()const; + void setCoreDiskSize(int coreDiskSize); + + private: + std::string clusterId_; + int logDiskSize_; + int coreDiskSize_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.h b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.h new file mode 100644 index 000000000..b47ac31dc --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.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_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeMultiZoneClusterDiskSizeResult : public ServiceResult + { + public: + + + ResizeMultiZoneClusterDiskSizeResult(); + explicit ResizeMultiZoneClusterDiskSizeResult(const std::string &payload); + ~ResizeMultiZoneClusterDiskSizeResult(); + std::string getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + std::string orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERDISKSIZERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h new file mode 100644 index 000000000..d8221e993 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h @@ -0,0 +1,69 @@ +/* + * 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_RESIZEMULTIZONECLUSTERNODECOUNTREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeMultiZoneClusterNodeCountRequest : public RpcServiceRequest + { + + public: + ResizeMultiZoneClusterNodeCountRequest(); + ~ResizeMultiZoneClusterNodeCountRequest(); + + std::string getPrimaryVSwitchId()const; + void setPrimaryVSwitchId(const std::string& primaryVSwitchId); + std::string getStandbyVSwitchId()const; + void setStandbyVSwitchId(const std::string& standbyVSwitchId); + int getLogNodeCount()const; + void setLogNodeCount(int logNodeCount); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getPrimaryCoreNodeCount()const; + void setPrimaryCoreNodeCount(int primaryCoreNodeCount); + int getCoreNodeCount()const; + void setCoreNodeCount(int coreNodeCount); + int getStandbyCoreNodeCount()const; + void setStandbyCoreNodeCount(int standbyCoreNodeCount); + std::string getArbiterVSwitchId()const; + void setArbiterVSwitchId(const std::string& arbiterVSwitchId); + + private: + std::string primaryVSwitchId_; + std::string standbyVSwitchId_; + int logNodeCount_; + std::string clusterId_; + int primaryCoreNodeCount_; + int coreNodeCount_; + int standbyCoreNodeCount_; + std::string arbiterVSwitchId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.h b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.h new file mode 100644 index 000000000..16d3bd874 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.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_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeMultiZoneClusterNodeCountResult : public ServiceResult + { + public: + + + ResizeMultiZoneClusterNodeCountResult(); + explicit ResizeMultiZoneClusterNodeCountResult(const std::string &payload); + ~ResizeMultiZoneClusterNodeCountResult(); + std::string getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + std::string orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEMULTIZONECLUSTERNODECOUNTRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h b/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h index 9dacdea1a..aa06bc702 100644 --- a/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h +++ b/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h @@ -37,12 +37,18 @@ namespace AlibabaCloud std::string getClusterId()const; void setClusterId(const std::string& clusterId); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); int getNodeCount()const; void setNodeCount(int nodeCount); + std::string getZoneId()const; + void setZoneId(const std::string& zoneId); private: std::string clusterId_; + std::string vSwitchId_; int nodeCount_; + std::string zoneId_; }; } diff --git a/hbase/src/HBaseClient.cc b/hbase/src/HBaseClient.cc index 5ccd205f2..c1dfbabd3 100644 --- a/hbase/src/HBaseClient.cc +++ b/hbase/src/HBaseClient.cc @@ -1707,6 +1707,42 @@ HBaseClient::ModifyIpWhitelistOutcomeCallable HBaseClient::modifyIpWhitelistCall return task->get_future(); } +HBaseClient::ModifyMultiZoneClusterNodeTypeOutcome HBaseClient::modifyMultiZoneClusterNodeType(const ModifyMultiZoneClusterNodeTypeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyMultiZoneClusterNodeTypeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyMultiZoneClusterNodeTypeOutcome(ModifyMultiZoneClusterNodeTypeResult(outcome.result())); + else + return ModifyMultiZoneClusterNodeTypeOutcome(outcome.error()); +} + +void HBaseClient::modifyMultiZoneClusterNodeTypeAsync(const ModifyMultiZoneClusterNodeTypeRequest& request, const ModifyMultiZoneClusterNodeTypeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyMultiZoneClusterNodeType(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ModifyMultiZoneClusterNodeTypeOutcomeCallable HBaseClient::modifyMultiZoneClusterNodeTypeCallable(const ModifyMultiZoneClusterNodeTypeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyMultiZoneClusterNodeType(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + HBaseClient::ModifySecurityGroupsOutcome HBaseClient::modifySecurityGroups(const ModifySecurityGroupsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1959,6 +1995,78 @@ HBaseClient::ResizeDiskSizeOutcomeCallable HBaseClient::resizeDiskSizeCallable(c return task->get_future(); } +HBaseClient::ResizeMultiZoneClusterDiskSizeOutcome HBaseClient::resizeMultiZoneClusterDiskSize(const ResizeMultiZoneClusterDiskSizeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ResizeMultiZoneClusterDiskSizeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ResizeMultiZoneClusterDiskSizeOutcome(ResizeMultiZoneClusterDiskSizeResult(outcome.result())); + else + return ResizeMultiZoneClusterDiskSizeOutcome(outcome.error()); +} + +void HBaseClient::resizeMultiZoneClusterDiskSizeAsync(const ResizeMultiZoneClusterDiskSizeRequest& request, const ResizeMultiZoneClusterDiskSizeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, resizeMultiZoneClusterDiskSize(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ResizeMultiZoneClusterDiskSizeOutcomeCallable HBaseClient::resizeMultiZoneClusterDiskSizeCallable(const ResizeMultiZoneClusterDiskSizeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->resizeMultiZoneClusterDiskSize(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ResizeMultiZoneClusterNodeCountOutcome HBaseClient::resizeMultiZoneClusterNodeCount(const ResizeMultiZoneClusterNodeCountRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ResizeMultiZoneClusterNodeCountOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ResizeMultiZoneClusterNodeCountOutcome(ResizeMultiZoneClusterNodeCountResult(outcome.result())); + else + return ResizeMultiZoneClusterNodeCountOutcome(outcome.error()); +} + +void HBaseClient::resizeMultiZoneClusterNodeCountAsync(const ResizeMultiZoneClusterNodeCountRequest& request, const ResizeMultiZoneClusterNodeCountAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, resizeMultiZoneClusterNodeCount(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ResizeMultiZoneClusterNodeCountOutcomeCallable HBaseClient::resizeMultiZoneClusterNodeCountCallable(const ResizeMultiZoneClusterNodeCountRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->resizeMultiZoneClusterNodeCount(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + HBaseClient::ResizeNodeCountOutcome HBaseClient::resizeNodeCount(const ResizeNodeCountRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/hbase/src/model/ModifyMultiZoneClusterNodeTypeRequest.cc b/hbase/src/model/ModifyMultiZoneClusterNodeTypeRequest.cc new file mode 100644 index 000000000..4b6f28cf1 --- /dev/null +++ b/hbase/src/model/ModifyMultiZoneClusterNodeTypeRequest.cc @@ -0,0 +1,73 @@ +/* + * 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::ModifyMultiZoneClusterNodeTypeRequest; + +ModifyMultiZoneClusterNodeTypeRequest::ModifyMultiZoneClusterNodeTypeRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ModifyMultiZoneClusterNodeType") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifyMultiZoneClusterNodeTypeRequest::~ModifyMultiZoneClusterNodeTypeRequest() +{} + +std::string ModifyMultiZoneClusterNodeTypeRequest::getLogInstanceType()const +{ + return logInstanceType_; +} + +void ModifyMultiZoneClusterNodeTypeRequest::setLogInstanceType(const std::string& logInstanceType) +{ + logInstanceType_ = logInstanceType; + setParameter("LogInstanceType", logInstanceType); +} + +std::string ModifyMultiZoneClusterNodeTypeRequest::getClusterId()const +{ + return clusterId_; +} + +void ModifyMultiZoneClusterNodeTypeRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setParameter("ClusterId", clusterId); +} + +std::string ModifyMultiZoneClusterNodeTypeRequest::getMasterInstanceType()const +{ + return masterInstanceType_; +} + +void ModifyMultiZoneClusterNodeTypeRequest::setMasterInstanceType(const std::string& masterInstanceType) +{ + masterInstanceType_ = masterInstanceType; + setParameter("MasterInstanceType", masterInstanceType); +} + +std::string ModifyMultiZoneClusterNodeTypeRequest::getCoreInstanceType()const +{ + return coreInstanceType_; +} + +void ModifyMultiZoneClusterNodeTypeRequest::setCoreInstanceType(const std::string& coreInstanceType) +{ + coreInstanceType_ = coreInstanceType; + setParameter("CoreInstanceType", coreInstanceType); +} + diff --git a/hbase/src/model/ModifyMultiZoneClusterNodeTypeResult.cc b/hbase/src/model/ModifyMultiZoneClusterNodeTypeResult.cc new file mode 100644 index 000000000..70b8f5950 --- /dev/null +++ b/hbase/src/model/ModifyMultiZoneClusterNodeTypeResult.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 +#include + +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +ModifyMultiZoneClusterNodeTypeResult::ModifyMultiZoneClusterNodeTypeResult() : + ServiceResult() +{} + +ModifyMultiZoneClusterNodeTypeResult::ModifyMultiZoneClusterNodeTypeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyMultiZoneClusterNodeTypeResult::~ModifyMultiZoneClusterNodeTypeResult() +{} + +void ModifyMultiZoneClusterNodeTypeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = value["OrderId"].asString(); + +} + +std::string ModifyMultiZoneClusterNodeTypeResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/ResizeMultiZoneClusterDiskSizeRequest.cc b/hbase/src/model/ResizeMultiZoneClusterDiskSizeRequest.cc new file mode 100644 index 000000000..e10b2f89b --- /dev/null +++ b/hbase/src/model/ResizeMultiZoneClusterDiskSizeRequest.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 + +using AlibabaCloud::HBase::Model::ResizeMultiZoneClusterDiskSizeRequest; + +ResizeMultiZoneClusterDiskSizeRequest::ResizeMultiZoneClusterDiskSizeRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ResizeMultiZoneClusterDiskSize") +{ + setMethod(HttpRequest::Method::Post); +} + +ResizeMultiZoneClusterDiskSizeRequest::~ResizeMultiZoneClusterDiskSizeRequest() +{} + +std::string ResizeMultiZoneClusterDiskSizeRequest::getClusterId()const +{ + return clusterId_; +} + +void ResizeMultiZoneClusterDiskSizeRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setParameter("ClusterId", clusterId); +} + +int ResizeMultiZoneClusterDiskSizeRequest::getLogDiskSize()const +{ + return logDiskSize_; +} + +void ResizeMultiZoneClusterDiskSizeRequest::setLogDiskSize(int logDiskSize) +{ + logDiskSize_ = logDiskSize; + setParameter("LogDiskSize", std::to_string(logDiskSize)); +} + +int ResizeMultiZoneClusterDiskSizeRequest::getCoreDiskSize()const +{ + return coreDiskSize_; +} + +void ResizeMultiZoneClusterDiskSizeRequest::setCoreDiskSize(int coreDiskSize) +{ + coreDiskSize_ = coreDiskSize; + setParameter("CoreDiskSize", std::to_string(coreDiskSize)); +} + diff --git a/hbase/src/model/ResizeMultiZoneClusterDiskSizeResult.cc b/hbase/src/model/ResizeMultiZoneClusterDiskSizeResult.cc new file mode 100644 index 000000000..b7faa8058 --- /dev/null +++ b/hbase/src/model/ResizeMultiZoneClusterDiskSizeResult.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 +#include + +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +ResizeMultiZoneClusterDiskSizeResult::ResizeMultiZoneClusterDiskSizeResult() : + ServiceResult() +{} + +ResizeMultiZoneClusterDiskSizeResult::ResizeMultiZoneClusterDiskSizeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ResizeMultiZoneClusterDiskSizeResult::~ResizeMultiZoneClusterDiskSizeResult() +{} + +void ResizeMultiZoneClusterDiskSizeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = value["OrderId"].asString(); + +} + +std::string ResizeMultiZoneClusterDiskSizeResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/ResizeMultiZoneClusterNodeCountRequest.cc b/hbase/src/model/ResizeMultiZoneClusterNodeCountRequest.cc new file mode 100644 index 000000000..df53386cb --- /dev/null +++ b/hbase/src/model/ResizeMultiZoneClusterNodeCountRequest.cc @@ -0,0 +1,117 @@ +/* + * 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::ResizeMultiZoneClusterNodeCountRequest; + +ResizeMultiZoneClusterNodeCountRequest::ResizeMultiZoneClusterNodeCountRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ResizeMultiZoneClusterNodeCount") +{ + setMethod(HttpRequest::Method::Post); +} + +ResizeMultiZoneClusterNodeCountRequest::~ResizeMultiZoneClusterNodeCountRequest() +{} + +std::string ResizeMultiZoneClusterNodeCountRequest::getPrimaryVSwitchId()const +{ + return primaryVSwitchId_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setPrimaryVSwitchId(const std::string& primaryVSwitchId) +{ + primaryVSwitchId_ = primaryVSwitchId; + setParameter("PrimaryVSwitchId", primaryVSwitchId); +} + +std::string ResizeMultiZoneClusterNodeCountRequest::getStandbyVSwitchId()const +{ + return standbyVSwitchId_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setStandbyVSwitchId(const std::string& standbyVSwitchId) +{ + standbyVSwitchId_ = standbyVSwitchId; + setParameter("StandbyVSwitchId", standbyVSwitchId); +} + +int ResizeMultiZoneClusterNodeCountRequest::getLogNodeCount()const +{ + return logNodeCount_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setLogNodeCount(int logNodeCount) +{ + logNodeCount_ = logNodeCount; + setParameter("LogNodeCount", std::to_string(logNodeCount)); +} + +std::string ResizeMultiZoneClusterNodeCountRequest::getClusterId()const +{ + return clusterId_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setParameter("ClusterId", clusterId); +} + +int ResizeMultiZoneClusterNodeCountRequest::getPrimaryCoreNodeCount()const +{ + return primaryCoreNodeCount_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setPrimaryCoreNodeCount(int primaryCoreNodeCount) +{ + primaryCoreNodeCount_ = primaryCoreNodeCount; + setParameter("PrimaryCoreNodeCount", std::to_string(primaryCoreNodeCount)); +} + +int ResizeMultiZoneClusterNodeCountRequest::getCoreNodeCount()const +{ + return coreNodeCount_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setCoreNodeCount(int coreNodeCount) +{ + coreNodeCount_ = coreNodeCount; + setParameter("CoreNodeCount", std::to_string(coreNodeCount)); +} + +int ResizeMultiZoneClusterNodeCountRequest::getStandbyCoreNodeCount()const +{ + return standbyCoreNodeCount_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setStandbyCoreNodeCount(int standbyCoreNodeCount) +{ + standbyCoreNodeCount_ = standbyCoreNodeCount; + setParameter("StandbyCoreNodeCount", std::to_string(standbyCoreNodeCount)); +} + +std::string ResizeMultiZoneClusterNodeCountRequest::getArbiterVSwitchId()const +{ + return arbiterVSwitchId_; +} + +void ResizeMultiZoneClusterNodeCountRequest::setArbiterVSwitchId(const std::string& arbiterVSwitchId) +{ + arbiterVSwitchId_ = arbiterVSwitchId; + setParameter("ArbiterVSwitchId", arbiterVSwitchId); +} + diff --git a/hbase/src/model/ResizeMultiZoneClusterNodeCountResult.cc b/hbase/src/model/ResizeMultiZoneClusterNodeCountResult.cc new file mode 100644 index 000000000..d6a97acaf --- /dev/null +++ b/hbase/src/model/ResizeMultiZoneClusterNodeCountResult.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 +#include + +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +ResizeMultiZoneClusterNodeCountResult::ResizeMultiZoneClusterNodeCountResult() : + ServiceResult() +{} + +ResizeMultiZoneClusterNodeCountResult::ResizeMultiZoneClusterNodeCountResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ResizeMultiZoneClusterNodeCountResult::~ResizeMultiZoneClusterNodeCountResult() +{} + +void ResizeMultiZoneClusterNodeCountResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = value["OrderId"].asString(); + +} + +std::string ResizeMultiZoneClusterNodeCountResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/ResizeNodeCountRequest.cc b/hbase/src/model/ResizeNodeCountRequest.cc index 1c8c38ad3..5c5a40592 100644 --- a/hbase/src/model/ResizeNodeCountRequest.cc +++ b/hbase/src/model/ResizeNodeCountRequest.cc @@ -38,6 +38,17 @@ void ResizeNodeCountRequest::setClusterId(const std::string& clusterId) setParameter("ClusterId", clusterId); } +std::string ResizeNodeCountRequest::getVSwitchId()const +{ + return vSwitchId_; +} + +void ResizeNodeCountRequest::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; + setParameter("VSwitchId", vSwitchId); +} + int ResizeNodeCountRequest::getNodeCount()const { return nodeCount_; @@ -49,3 +60,14 @@ void ResizeNodeCountRequest::setNodeCount(int nodeCount) setParameter("NodeCount", std::to_string(nodeCount)); } +std::string ResizeNodeCountRequest::getZoneId()const +{ + return zoneId_; +} + +void ResizeNodeCountRequest::setZoneId(const std::string& zoneId) +{ + zoneId_ = zoneId; + setParameter("ZoneId", zoneId); +} +