1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add support for enable hbaseue extra module like lindorm-search or lindorm-sql.

Browse Source
This commit is contained in:
sdk-team
2020-06-12 10:59:41 +08:00
parent 07b50e30ef
commit 654af055e6
9 changed files with 489 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-06-12 Version: 1.36.457
- Add support for enable hbaseue extra module like lindorm-search or lindorm-sql.
2020-06-11 Version: 1.36.456
- Support ServicePeriodUnit in QueryInstanceBill.

2
VERSION
View File

@@ -1 +1 @@
1.36.456
1.36.457

4
hbase/CMakeLists.txt
View File

@@ -85,6 +85,8 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h
include/alibabacloud/hbase/model/EnableHBaseueBackupRequest.h
include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h
include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h
include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h
include/alibabacloud/hbase/model/ListTagResourcesRequest.h
include/alibabacloud/hbase/model/ListTagResourcesResult.h
include/alibabacloud/hbase/model/ListTagsRequest.h
@@ -192,6 +194,8 @@ set(hbase_src
src/model/DescribeSecurityGroupsResult.cc
src/model/EnableHBaseueBackupRequest.cc
src/model/EnableHBaseueBackupResult.cc
src/model/EnableHBaseueModuleRequest.cc
src/model/EnableHBaseueModuleResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ListTagsRequest.cc

8
hbase/include/alibabacloud/hbase/HBaseClient.h
View File

@@ -86,6 +86,8 @@
#include "model/DescribeSecurityGroupsResult.h"
#include "model/EnableHBaseueBackupRequest.h"
#include "model/EnableHBaseueBackupResult.h"
#include "model/EnableHBaseueModuleRequest.h"
#include "model/EnableHBaseueModuleResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ListTagsRequest.h"
@@ -231,6 +233,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::EnableHBaseueBackupResult> EnableHBaseueBackupOutcome;
typedef std::future<EnableHBaseueBackupOutcome> EnableHBaseueBackupOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::EnableHBaseueBackupRequest&, const EnableHBaseueBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHBaseueBackupAsyncHandler;
typedef Outcome<Error, Model::EnableHBaseueModuleResult> EnableHBaseueModuleOutcome;
typedef std::future<EnableHBaseueModuleOutcome> EnableHBaseueModuleOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::EnableHBaseueModuleRequest&, const EnableHBaseueModuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHBaseueModuleAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
@@ -392,6 +397,9 @@ namespace AlibabaCloud
EnableHBaseueBackupOutcome enableHBaseueBackup(const Model::EnableHBaseueBackupRequest &request)const;
void enableHBaseueBackupAsync(const Model::EnableHBaseueBackupRequest& request, const EnableHBaseueBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableHBaseueBackupOutcomeCallable enableHBaseueBackupCallable(const Model::EnableHBaseueBackupRequest& request) const;
EnableHBaseueModuleOutcome enableHBaseueModule(const Model::EnableHBaseueModuleRequest &request)const;
void enableHBaseueModuleAsync(const Model::EnableHBaseueModuleRequest& request, const EnableHBaseueModuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableHBaseueModuleOutcomeCallable enableHBaseueModuleCallable(const Model::EnableHBaseueModuleRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;

99
hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULEREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT EnableHBaseueModuleRequest : public RpcServiceRequest
{
public:
EnableHBaseueModuleRequest();
~EnableHBaseueModuleRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getModuleTypeName()const;
void setModuleTypeName(const std::string& moduleTypeName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getHbaseueClusterId()const;
void setHbaseueClusterId(const std::string& hbaseueClusterId);
std::string getBdsId()const;
void setBdsId(const std::string& bdsId);
std::string getModuleClusterName()const;
void setModuleClusterName(const std::string& moduleClusterName);
int getAutoRenewPeriod()const;
void setAutoRenewPeriod(int autoRenewPeriod);
int getPeriod()const;
void setPeriod(int period);
int getDiskSize()const;
void setDiskSize(int diskSize);
std::string getMasterInstanceType()const;
void setMasterInstanceType(const std::string& masterInstanceType);
std::string getDiskType()const;
void setDiskType(const std::string& diskType);
std::string getVswitchId()const;
void setVswitchId(const std::string& vswitchId);
std::string getPeriodUnit()const;
void setPeriodUnit(const std::string& periodUnit);
std::string getCoreInstanceType()const;
void setCoreInstanceType(const std::string& coreInstanceType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
int getNodeCount()const;
void setNodeCount(int nodeCount);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
std::string getPayType()const;
void setPayType(const std::string& payType);
private:
std::string clientToken_;
std::string moduleTypeName_;
std::string regionId_;
std::string hbaseueClusterId_;
std::string bdsId_;
std::string moduleClusterName_;
int autoRenewPeriod_;
int period_;
int diskSize_;
std::string masterInstanceType_;
std::string diskType_;
std::string vswitchId_;
std::string periodUnit_;
std::string coreInstanceType_;
std::string vpcId_;
int nodeCount_;
std::string zoneId_;
std::string payType_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULEREQUEST_H_

53
hbase/include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULERESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULERESULT_H_
#include <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 EnableHBaseueModuleResult : public ServiceResult
{
public:
EnableHBaseueModuleResult();
explicit EnableHBaseueModuleResult(const std::string &payload);
~EnableHBaseueModuleResult();
std::string getClusterId()const;
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string clusterId_;
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEMODULERESULT_H_

36
hbase/src/HBaseClient.cc
View File

@@ -1203,6 +1203,42 @@ HBaseClient::EnableHBaseueBackupOutcomeCallable HBaseClient::enableHBaseueBackup
return task->get_future();
}
HBaseClient::EnableHBaseueModuleOutcome HBaseClient::enableHBaseueModule(const EnableHBaseueModuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EnableHBaseueModuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EnableHBaseueModuleOutcome(EnableHBaseueModuleResult(outcome.result()));
else
return EnableHBaseueModuleOutcome(outcome.error());
}
void HBaseClient::enableHBaseueModuleAsync(const EnableHBaseueModuleRequest& request, const EnableHBaseueModuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, enableHBaseueModule(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::EnableHBaseueModuleOutcomeCallable HBaseClient::enableHBaseueModuleCallable(const EnableHBaseueModuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EnableHBaseueModuleOutcome()>>(
[this, request]()
{
return this->enableHBaseueModule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

227
hbase/src/model/EnableHBaseueModuleRequest.cc Normal file
View File

@@ -0,0 +1,227 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/EnableHBaseueModuleRequest.h>
using AlibabaCloud::HBase::Model::EnableHBaseueModuleRequest;
EnableHBaseueModuleRequest::EnableHBaseueModuleRequest() :
RpcServiceRequest("hbase", "2019-01-01", "EnableHBaseueModule")
{
setMethod(HttpRequest::Method::Post);
}
EnableHBaseueModuleRequest::~EnableHBaseueModuleRequest()
{}
std::string EnableHBaseueModuleRequest::getClientToken()const
{
return clientToken_;
}
void EnableHBaseueModuleRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string EnableHBaseueModuleRequest::getModuleTypeName()const
{
return moduleTypeName_;
}
void EnableHBaseueModuleRequest::setModuleTypeName(const std::string& moduleTypeName)
{
moduleTypeName_ = moduleTypeName;
setParameter("ModuleTypeName", moduleTypeName);
}
std::string EnableHBaseueModuleRequest::getRegionId()const
{
return regionId_;
}
void EnableHBaseueModuleRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string EnableHBaseueModuleRequest::getHbaseueClusterId()const
{
return hbaseueClusterId_;
}
void EnableHBaseueModuleRequest::setHbaseueClusterId(const std::string& hbaseueClusterId)
{
hbaseueClusterId_ = hbaseueClusterId;
setParameter("HbaseueClusterId", hbaseueClusterId);
}
std::string EnableHBaseueModuleRequest::getBdsId()const
{
return bdsId_;
}
void EnableHBaseueModuleRequest::setBdsId(const std::string& bdsId)
{
bdsId_ = bdsId;
setParameter("BdsId", bdsId);
}
std::string EnableHBaseueModuleRequest::getModuleClusterName()const
{
return moduleClusterName_;
}
void EnableHBaseueModuleRequest::setModuleClusterName(const std::string& moduleClusterName)
{
moduleClusterName_ = moduleClusterName;
setParameter("ModuleClusterName", moduleClusterName);
}
int EnableHBaseueModuleRequest::getAutoRenewPeriod()const
{
return autoRenewPeriod_;
}
void EnableHBaseueModuleRequest::setAutoRenewPeriod(int autoRenewPeriod)
{
autoRenewPeriod_ = autoRenewPeriod;
setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
}
int EnableHBaseueModuleRequest::getPeriod()const
{
return period_;
}
void EnableHBaseueModuleRequest::setPeriod(int period)
{
period_ = period;
setParameter("Period", std::to_string(period));
}
int EnableHBaseueModuleRequest::getDiskSize()const
{
return diskSize_;
}
void EnableHBaseueModuleRequest::setDiskSize(int diskSize)
{
diskSize_ = diskSize;
setParameter("DiskSize", std::to_string(diskSize));
}
std::string EnableHBaseueModuleRequest::getMasterInstanceType()const
{
return masterInstanceType_;
}
void EnableHBaseueModuleRequest::setMasterInstanceType(const std::string& masterInstanceType)
{
masterInstanceType_ = masterInstanceType;
setParameter("MasterInstanceType", masterInstanceType);
}
std::string EnableHBaseueModuleRequest::getDiskType()const
{
return diskType_;
}
void EnableHBaseueModuleRequest::setDiskType(const std::string& diskType)
{
diskType_ = diskType;
setParameter("DiskType", diskType);
}
std::string EnableHBaseueModuleRequest::getVswitchId()const
{
return vswitchId_;
}
void EnableHBaseueModuleRequest::setVswitchId(const std::string& vswitchId)
{
vswitchId_ = vswitchId;
setParameter("VswitchId", vswitchId);
}
std::string EnableHBaseueModuleRequest::getPeriodUnit()const
{
return periodUnit_;
}
void EnableHBaseueModuleRequest::setPeriodUnit(const std::string& periodUnit)
{
periodUnit_ = periodUnit;
setParameter("PeriodUnit", periodUnit);
}
std::string EnableHBaseueModuleRequest::getCoreInstanceType()const
{
return coreInstanceType_;
}
void EnableHBaseueModuleRequest::setCoreInstanceType(const std::string& coreInstanceType)
{
coreInstanceType_ = coreInstanceType;
setParameter("CoreInstanceType", coreInstanceType);
}
std::string EnableHBaseueModuleRequest::getVpcId()const
{
return vpcId_;
}
void EnableHBaseueModuleRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setParameter("VpcId", vpcId);
}
int EnableHBaseueModuleRequest::getNodeCount()const
{
return nodeCount_;
}
void EnableHBaseueModuleRequest::setNodeCount(int nodeCount)
{
nodeCount_ = nodeCount;
setParameter("NodeCount", std::to_string(nodeCount));
}
std::string EnableHBaseueModuleRequest::getZoneId()const
{
return zoneId_;
}
void EnableHBaseueModuleRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string EnableHBaseueModuleRequest::getPayType()const
{
return payType_;
}
void EnableHBaseueModuleRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}

58
hbase/src/model/EnableHBaseueModuleResult.cc Normal file
View File

@@ -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/EnableHBaseueModuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
EnableHBaseueModuleResult::EnableHBaseueModuleResult() :
ServiceResult()
{}
EnableHBaseueModuleResult::EnableHBaseueModuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EnableHBaseueModuleResult::~EnableHBaseueModuleResult()
{}
void EnableHBaseueModuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
std::string EnableHBaseueModuleResult::getClusterId()const
{
return clusterId_;
}
std::string EnableHBaseueModuleResult::getOrderId()const
{
return orderId_;
}