Support create for serverlesshbase.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-09-24 Version: patch
+- Support create for serverlesshbase.
+
 2020-09-24 Version: patch
 - ContrastFaceVerify API Add Model Parameter.
 

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

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<Error, Model::CreateRestorePlanResult> CreateRestorePlanOutcome;
 			typedef std::future<CreateRestorePlanOutcome> CreateRestorePlanOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::CreateRestorePlanRequest&, const CreateRestorePlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRestorePlanAsyncHandler;
+			typedef Outcome<Error, Model::CreateServerlessClusterResult> CreateServerlessClusterOutcome;
+			typedef std::future<CreateServerlessClusterOutcome> CreateServerlessClusterOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::CreateServerlessClusterRequest&, const CreateServerlessClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServerlessClusterAsyncHandler;
 			typedef Outcome<Error, Model::DeleteHBaseHaDBResult> DeleteHBaseHaDBOutcome;
 			typedef std::future<DeleteHBaseHaDBOutcome> DeleteHBaseHaDBOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DeleteHBaseHaDBRequest&, const DeleteHBaseHaDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
 			DeleteHBaseHaDBOutcomeCallable deleteHBaseHaDBCallable(const Model::DeleteHBaseHaDBRequest& request) const;

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 <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+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_

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 <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT 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_

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

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

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