Support for resize hbaseue multi-zone cluster.

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<const AsyncCallerContext>& 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<std::packaged_task<ModifyMultiZoneClusterNodeTypeOutcome()>>(
+			[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<const AsyncCallerContext>& 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<std::packaged_task<ResizeMultiZoneClusterDiskSizeOutcome()>>(
+			[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<const AsyncCallerContext>& 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<std::packaged_task<ResizeMultiZoneClusterNodeCountOutcome()>>(
+			[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();

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 <alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeRequest.h>
+
+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);
+}
+

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 <alibabacloud/hbase/model/ModifyMultiZoneClusterNodeTypeResult.h>
+#include <json/json.h>
+
+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_;
+}
+

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 <alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeRequest.h>
+
+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));
+}
+

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 <alibabacloud/hbase/model/ResizeMultiZoneClusterDiskSizeResult.h>
+#include <json/json.h>
+
+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_;
+}
+

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 <alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountRequest.h>
+
+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);
+}
+

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 <alibabacloud/hbase/model/ResizeMultiZoneClusterNodeCountResult.h>
+#include <json/json.h>
+
+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_;
+}
+

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);
+}
+