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

Support for describe hbaseue multi-zone model.

Browse Source
This commit is contained in:
sdk-team
2020-08-18 15:18:22 +08:00
parent 06eedce285
commit e20435dd22
29 changed files with 2516 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-08-18 Version: 1.36.598
- Support for describe hbaseue multi-zone model.
2020-08-18 Version: 1.36.597
- Support session query operations.

2
VERSION
View File

@@ -1 +1 @@
1.36.597
1.36.598

24
hbase/CMakeLists.txt
View File

@@ -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/DeleteHBaseHaDBRequest.h
include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h
include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h
include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.h
include/alibabacloud/hbase/model/DeleteInstanceRequest.h
@@ -67,6 +69,12 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/DescribeInstancesResult.h
include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h
include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h
include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h
include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h
include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h
include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h
include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h
include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h
include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeRequest.h
include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeResult.h
include/alibabacloud/hbase/model/DescribeRegionsRequest.h
@@ -87,6 +95,8 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h
include/alibabacloud/hbase/model/EnableHBaseueModuleRequest.h
include/alibabacloud/hbase/model/EnableHBaseueModuleResult.h
include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h
include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h
include/alibabacloud/hbase/model/ListTagResourcesRequest.h
include/alibabacloud/hbase/model/ListTagResourcesResult.h
include/alibabacloud/hbase/model/ListTagsRequest.h
@@ -125,6 +135,8 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/TagResourcesResult.h
include/alibabacloud/hbase/model/UnTagResourcesRequest.h
include/alibabacloud/hbase/model/UnTagResourcesResult.h
include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h
include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h
include/alibabacloud/hbase/model/XpackRelateDBRequest.h
include/alibabacloud/hbase/model/XpackRelateDBResult.h )
@@ -144,6 +156,8 @@ set(hbase_src
src/model/CreateMultiZoneClusterResult.cc
src/model/CreateRestorePlanRequest.cc
src/model/CreateRestorePlanResult.cc
src/model/DeleteHBaseHaDBRequest.cc
src/model/DeleteHBaseHaDBResult.cc
src/model/DeleteHbaseHaSlbRequest.cc
src/model/DeleteHbaseHaSlbResult.cc
src/model/DeleteInstanceRequest.cc
@@ -176,6 +190,12 @@ set(hbase_src
src/model/DescribeInstancesResult.cc
src/model/DescribeIpWhitelistRequest.cc
src/model/DescribeIpWhitelistResult.cc
src/model/DescribeMultiZoneAvailableRegionsRequest.cc
src/model/DescribeMultiZoneAvailableRegionsResult.cc
src/model/DescribeMultiZoneAvailableResourceRequest.cc
src/model/DescribeMultiZoneAvailableResourceResult.cc
src/model/DescribeMultiZoneClusterRequest.cc
src/model/DescribeMultiZoneClusterResult.cc
src/model/DescribeRecoverableTimeRangeRequest.cc
src/model/DescribeRecoverableTimeRangeResult.cc
src/model/DescribeRegionsRequest.cc
@@ -196,6 +216,8 @@ set(hbase_src
src/model/EnableHBaseueBackupResult.cc
src/model/EnableHBaseueModuleRequest.cc
src/model/EnableHBaseueModuleResult.cc
src/model/EvaluateMultiZoneResourceRequest.cc
src/model/EvaluateMultiZoneResourceResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ListTagsRequest.cc
@@ -234,6 +256,8 @@ set(hbase_src
src/model/TagResourcesResult.cc
src/model/UnTagResourcesRequest.cc
src/model/UnTagResourcesResult.cc
src/model/UpgradeMultiZoneClusterRequest.cc
src/model/UpgradeMultiZoneClusterResult.cc
src/model/XpackRelateDBRequest.cc
src/model/XpackRelateDBResult.cc )

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

@@ -36,6 +36,8 @@
#include "model/CreateMultiZoneClusterResult.h"
#include "model/CreateRestorePlanRequest.h"
#include "model/CreateRestorePlanResult.h"
#include "model/DeleteHBaseHaDBRequest.h"
#include "model/DeleteHBaseHaDBResult.h"
#include "model/DeleteHbaseHaSlbRequest.h"
#include "model/DeleteHbaseHaSlbResult.h"
#include "model/DeleteInstanceRequest.h"
@@ -68,6 +70,12 @@
#include "model/DescribeInstancesResult.h"
#include "model/DescribeIpWhitelistRequest.h"
#include "model/DescribeIpWhitelistResult.h"
#include "model/DescribeMultiZoneAvailableRegionsRequest.h"
#include "model/DescribeMultiZoneAvailableRegionsResult.h"
#include "model/DescribeMultiZoneAvailableResourceRequest.h"
#include "model/DescribeMultiZoneAvailableResourceResult.h"
#include "model/DescribeMultiZoneClusterRequest.h"
#include "model/DescribeMultiZoneClusterResult.h"
#include "model/DescribeRecoverableTimeRangeRequest.h"
#include "model/DescribeRecoverableTimeRangeResult.h"
#include "model/DescribeRegionsRequest.h"
@@ -88,6 +96,8 @@
#include "model/EnableHBaseueBackupResult.h"
#include "model/EnableHBaseueModuleRequest.h"
#include "model/EnableHBaseueModuleResult.h"
#include "model/EvaluateMultiZoneResourceRequest.h"
#include "model/EvaluateMultiZoneResourceResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ListTagsRequest.h"
@@ -126,6 +136,8 @@
#include "model/TagResourcesResult.h"
#include "model/UnTagResourcesRequest.h"
#include "model/UnTagResourcesResult.h"
#include "model/UpgradeMultiZoneClusterRequest.h"
#include "model/UpgradeMultiZoneClusterResult.h"
#include "model/XpackRelateDBRequest.h"
#include "model/XpackRelateDBResult.h"
@@ -158,6 +170,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::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;
typedef Outcome<Error, Model::DeleteHbaseHaSlbResult> DeleteHbaseHaSlbOutcome;
typedef std::future<DeleteHbaseHaSlbOutcome> DeleteHbaseHaSlbOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DeleteHbaseHaSlbRequest&, const DeleteHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHbaseHaSlbAsyncHandler;
@@ -206,6 +221,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeIpWhitelistResult> DescribeIpWhitelistOutcome;
typedef std::future<DescribeIpWhitelistOutcome> DescribeIpWhitelistOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeIpWhitelistRequest&, const DescribeIpWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIpWhitelistAsyncHandler;
typedef Outcome<Error, Model::DescribeMultiZoneAvailableRegionsResult> DescribeMultiZoneAvailableRegionsOutcome;
typedef std::future<DescribeMultiZoneAvailableRegionsOutcome> DescribeMultiZoneAvailableRegionsOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeMultiZoneAvailableRegionsRequest&, const DescribeMultiZoneAvailableRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMultiZoneAvailableRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeMultiZoneAvailableResourceResult> DescribeMultiZoneAvailableResourceOutcome;
typedef std::future<DescribeMultiZoneAvailableResourceOutcome> DescribeMultiZoneAvailableResourceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeMultiZoneAvailableResourceRequest&, const DescribeMultiZoneAvailableResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMultiZoneAvailableResourceAsyncHandler;
typedef Outcome<Error, Model::DescribeMultiZoneClusterResult> DescribeMultiZoneClusterOutcome;
typedef std::future<DescribeMultiZoneClusterOutcome> DescribeMultiZoneClusterOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeMultiZoneClusterRequest&, const DescribeMultiZoneClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMultiZoneClusterAsyncHandler;
typedef Outcome<Error, Model::DescribeRecoverableTimeRangeResult> DescribeRecoverableTimeRangeOutcome;
typedef std::future<DescribeRecoverableTimeRangeOutcome> DescribeRecoverableTimeRangeOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeRecoverableTimeRangeRequest&, const DescribeRecoverableTimeRangeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecoverableTimeRangeAsyncHandler;
@@ -236,6 +260,9 @@ namespace AlibabaCloud
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::EvaluateMultiZoneResourceResult> EvaluateMultiZoneResourceOutcome;
typedef std::future<EvaluateMultiZoneResourceOutcome> EvaluateMultiZoneResourceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::EvaluateMultiZoneResourceRequest&, const EvaluateMultiZoneResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EvaluateMultiZoneResourceAsyncHandler;
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;
@@ -293,6 +320,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UnTagResourcesResult> UnTagResourcesOutcome;
typedef std::future<UnTagResourcesOutcome> UnTagResourcesOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::UnTagResourcesRequest&, const UnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagResourcesAsyncHandler;
typedef Outcome<Error, Model::UpgradeMultiZoneClusterResult> UpgradeMultiZoneClusterOutcome;
typedef std::future<UpgradeMultiZoneClusterOutcome> UpgradeMultiZoneClusterOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::UpgradeMultiZoneClusterRequest&, const UpgradeMultiZoneClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeMultiZoneClusterAsyncHandler;
typedef Outcome<Error, Model::XpackRelateDBResult> XpackRelateDBOutcome;
typedef std::future<XpackRelateDBOutcome> XpackRelateDBOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::XpackRelateDBRequest&, const XpackRelateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> XpackRelateDBAsyncHandler;
@@ -322,6 +352,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;
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;
DeleteHbaseHaSlbOutcome deleteHbaseHaSlb(const Model::DeleteHbaseHaSlbRequest &request)const;
void deleteHbaseHaSlbAsync(const Model::DeleteHbaseHaSlbRequest& request, const DeleteHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteHbaseHaSlbOutcomeCallable deleteHbaseHaSlbCallable(const Model::DeleteHbaseHaSlbRequest& request) const;
@@ -370,6 +403,15 @@ namespace AlibabaCloud
DescribeIpWhitelistOutcome describeIpWhitelist(const Model::DescribeIpWhitelistRequest &request)const;
void describeIpWhitelistAsync(const Model::DescribeIpWhitelistRequest& request, const DescribeIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeIpWhitelistOutcomeCallable describeIpWhitelistCallable(const Model::DescribeIpWhitelistRequest& request) const;
DescribeMultiZoneAvailableRegionsOutcome describeMultiZoneAvailableRegions(const Model::DescribeMultiZoneAvailableRegionsRequest &request)const;
void describeMultiZoneAvailableRegionsAsync(const Model::DescribeMultiZoneAvailableRegionsRequest& request, const DescribeMultiZoneAvailableRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMultiZoneAvailableRegionsOutcomeCallable describeMultiZoneAvailableRegionsCallable(const Model::DescribeMultiZoneAvailableRegionsRequest& request) const;
DescribeMultiZoneAvailableResourceOutcome describeMultiZoneAvailableResource(const Model::DescribeMultiZoneAvailableResourceRequest &request)const;
void describeMultiZoneAvailableResourceAsync(const Model::DescribeMultiZoneAvailableResourceRequest& request, const DescribeMultiZoneAvailableResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMultiZoneAvailableResourceOutcomeCallable describeMultiZoneAvailableResourceCallable(const Model::DescribeMultiZoneAvailableResourceRequest& request) const;
DescribeMultiZoneClusterOutcome describeMultiZoneCluster(const Model::DescribeMultiZoneClusterRequest &request)const;
void describeMultiZoneClusterAsync(const Model::DescribeMultiZoneClusterRequest& request, const DescribeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMultiZoneClusterOutcomeCallable describeMultiZoneClusterCallable(const Model::DescribeMultiZoneClusterRequest& request) const;
DescribeRecoverableTimeRangeOutcome describeRecoverableTimeRange(const Model::DescribeRecoverableTimeRangeRequest &request)const;
void describeRecoverableTimeRangeAsync(const Model::DescribeRecoverableTimeRangeRequest& request, const DescribeRecoverableTimeRangeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRecoverableTimeRangeOutcomeCallable describeRecoverableTimeRangeCallable(const Model::DescribeRecoverableTimeRangeRequest& request) const;
@@ -400,6 +442,9 @@ namespace AlibabaCloud
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;
EvaluateMultiZoneResourceOutcome evaluateMultiZoneResource(const Model::EvaluateMultiZoneResourceRequest &request)const;
void evaluateMultiZoneResourceAsync(const Model::EvaluateMultiZoneResourceRequest& request, const EvaluateMultiZoneResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EvaluateMultiZoneResourceOutcomeCallable evaluateMultiZoneResourceCallable(const Model::EvaluateMultiZoneResourceRequest& 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;
@@ -457,6 +502,9 @@ namespace AlibabaCloud
UnTagResourcesOutcome unTagResources(const Model::UnTagResourcesRequest &request)const;
void unTagResourcesAsync(const Model::UnTagResourcesRequest& request, const UnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnTagResourcesOutcomeCallable unTagResourcesCallable(const Model::UnTagResourcesRequest& request) const;
UpgradeMultiZoneClusterOutcome upgradeMultiZoneCluster(const Model::UpgradeMultiZoneClusterRequest &request)const;
void upgradeMultiZoneClusterAsync(const Model::UpgradeMultiZoneClusterRequest& request, const UpgradeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpgradeMultiZoneClusterOutcomeCallable upgradeMultiZoneClusterCallable(const Model::UpgradeMultiZoneClusterRequest& request) const;
XpackRelateDBOutcome xpackRelateDB(const Model::XpackRelateDBRequest &request)const;
void xpackRelateDBAsync(const Model::XpackRelateDBRequest& request, const XpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
XpackRelateDBOutcomeCallable xpackRelateDBCallable(const Model::XpackRelateDBRequest& request) const;

51
hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h Normal file
View File

@@ -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_DELETEHBASEHADBREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBREQUEST_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 DeleteHBaseHaDBRequest : public RpcServiceRequest
{
public:
DeleteHBaseHaDBRequest();
~DeleteHBaseHaDBRequest();
std::string getHaId()const;
void setHaId(const std::string& haId);
std::string getBdsId()const;
void setBdsId(const std::string& bdsId);
private:
std::string haId_;
std::string bdsId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_DELETEHBASEHADBRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBRESULT_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 DeleteHBaseHaDBResult : public ServiceResult
{
public:
DeleteHBaseHaDBResult();
explicit DeleteHBaseHaDBResult(const std::string &payload);
~DeleteHBaseHaDBResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBRESULT_H_

48
hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_DESCRIBEMULTIZONEAVAILABLEREGIONSREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSREQUEST_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 DescribeMultiZoneAvailableRegionsRequest : public RpcServiceRequest
{
public:
DescribeMultiZoneAvailableRegionsRequest();
~DescribeMultiZoneAvailableRegionsRequest();
std::string getAcceptLanguage()const;
void setAcceptLanguage(const std::string& acceptLanguage);
private:
std::string acceptLanguage_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSREQUEST_H_

63
hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* 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_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_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 DescribeMultiZoneAvailableRegionsResult : public ServiceResult
{
public:
struct Region
{
struct AvailableCombine
{
std::string id;
std::vector<std::string> zones;
};
std::string regionId;
std::vector<Region::AvailableCombine> availableCombines;
std::string regionEndpoint;
std::string localName;
};
DescribeMultiZoneAvailableRegionsResult();
explicit DescribeMultiZoneAvailableRegionsResult(const std::string &payload);
~DescribeMultiZoneAvailableRegionsResult();
std::vector<Region> getRegions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Region> regions_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_H_

54
hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h Normal file
View File

@@ -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_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_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 DescribeMultiZoneAvailableResourceRequest : public RpcServiceRequest
{
public:
DescribeMultiZoneAvailableResourceRequest();
~DescribeMultiZoneAvailableResourceRequest();
std::string getZoneCombination()const;
void setZoneCombination(const std::string& zoneCombination);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getChargeType()const;
void setChargeType(const std::string& chargeType);
private:
std::string zoneCombination_;
std::string regionId_;
std::string chargeType_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_

106
hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_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 DescribeMultiZoneAvailableResourceResult : public ServiceResult
{
public:
struct AvailableZone
{
struct MasterResource
{
struct InstanceTypeDetail
{
int mem;
int cpu;
};
InstanceTypeDetail instanceTypeDetail;
std::string instanceType;
};
struct SupportedEngine
{
struct SupportedEngineVersion
{
struct SupportedCategoriesItem
{
struct SupportedStorageType
{
struct CoreResource
{
struct DBInstanceStorageRange
{
int minSize;
int stepSize;
int maxSize;
};
struct InstanceTypeDetail1
{
int mem;
int cpu;
};
InstanceTypeDetail1 instanceTypeDetail1;
DBInstanceStorageRange dBInstanceStorageRange;
std::string instanceType;
int maxCoreCount;
};
std::string storageType;
std::vector<SupportedStorageType::CoreResource> coreResources;
};
std::string category;
std::vector<SupportedCategoriesItem::SupportedStorageType> supportedStorageTypes;
};
std::string version;
std::vector<SupportedEngineVersion::SupportedCategoriesItem> supportedCategories;
};
std::vector<SupportedEngine::SupportedEngineVersion> supportedEngineVersions;
std::string engine;
};
std::vector<AvailableZone::MasterResource> masterResources;
std::string zoneCombination;
std::vector<AvailableZone::SupportedEngine> supportedEngines;
std::string regionId;
};
DescribeMultiZoneAvailableResourceResult();
explicit DescribeMultiZoneAvailableResourceResult(const std::string &payload);
~DescribeMultiZoneAvailableResourceResult();
std::vector<AvailableZone> getAvailableZones()const;
protected:
void parse(const std::string &payload);
private:
std::vector<AvailableZone> availableZones_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_

48
hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_DESCRIBEMULTIZONECLUSTERREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERREQUEST_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 DescribeMultiZoneClusterRequest : public RpcServiceRequest
{
public:
DescribeMultiZoneClusterRequest();
~DescribeMultiZoneClusterRequest();
std::string getClusterId()const;
void setClusterId(const std::string& clusterId);
private:
std::string clusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERREQUEST_H_

154
hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h Normal file
View File

@@ -0,0 +1,154 @@
/*
* 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_DESCRIBEMULTIZONECLUSTERRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_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 DescribeMultiZoneClusterResult : public ServiceResult
{
public:
struct MultiZoneInstanceModel
{
std::string status;
std::string role;
bool isLatestVersion;
std::string minorVersion;
std::string insName;
};
struct Tag
{
std::string value;
std::string key;
};
DescribeMultiZoneClusterResult();
explicit DescribeMultiZoneClusterResult(const std::string &payload);
~DescribeMultiZoneClusterResult();
std::string getModuleStackVersion()const;
std::string getStandbyZoneId()const;
std::string getCreatedTime()const;
std::string getMasterInstanceType()const;
std::string getPrimaryVSwitchIds()const;
bool getIsDeletionProtection()const;
std::string getLogDiskCount()const;
int getLogDiskSize()const;
int getModuleId()const;
std::string getArbiterVSwitchIds()const;
std::string getMaintainEndTime()const;
std::string getStandbyVSwitchIds()const;
std::string getNetworkType()const;
std::string getCoreInstanceType()const;
std::string getClusterName()const;
std::string getMasterDiskType()const;
std::vector<Tag> getTags()const;
std::string getEngine()const;
std::string getMaintainStartTime()const;
std::string getArbiterZoneId()const;
std::string getMajorVersion()const;
std::string getCoreDiskCount()const;
std::string getParentId()const;
std::string getStatus()const;
std::vector<MultiZoneInstanceModel> getMultiZoneInstanceModels()const;
std::string getExpireTimeUTC()const;
int getMasterDiskSize()const;
std::string getPrimaryZoneId()const;
std::string getMultiZoneCombination()const;
std::string getClusterId()const;
std::string getInstanceId()const;
int getCoreNodeCount()const;
std::string getCreatedTimeUTC()const;
int getDuration()const;
std::string getLogInstanceType()const;
std::string getPayType()const;
std::string getInstanceName()const;
int getMasterNodeCount()const;
bool getAutoRenewal()const;
std::string getVpcId()const;
std::string getCoreDiskType()const;
int getLogNodeCount()const;
std::string getLogDiskType()const;
std::string getRegionId()const;
std::string getExpireTime()const;
int getCoreDiskSize()const;
protected:
void parse(const std::string &payload);
private:
std::string moduleStackVersion_;
std::string standbyZoneId_;
std::string createdTime_;
std::string masterInstanceType_;
std::string primaryVSwitchIds_;
bool isDeletionProtection_;
std::string logDiskCount_;
int logDiskSize_;
int moduleId_;
std::string arbiterVSwitchIds_;
std::string maintainEndTime_;
std::string standbyVSwitchIds_;
std::string networkType_;
std::string coreInstanceType_;
std::string clusterName_;
std::string masterDiskType_;
std::vector<Tag> tags_;
std::string engine_;
std::string maintainStartTime_;
std::string arbiterZoneId_;
std::string majorVersion_;
std::string coreDiskCount_;
std::string parentId_;
std::string status_;
std::vector<MultiZoneInstanceModel> multiZoneInstanceModels_;
std::string expireTimeUTC_;
int masterDiskSize_;
std::string primaryZoneId_;
std::string multiZoneCombination_;
std::string clusterId_;
std::string instanceId_;
int coreNodeCount_;
std::string createdTimeUTC_;
int duration_;
std::string logInstanceType_;
std::string payType_;
std::string instanceName_;
int masterNodeCount_;
bool autoRenewal_;
std::string vpcId_;
std::string coreDiskType_;
int logNodeCount_;
std::string logDiskType_;
std::string regionId_;
std::string expireTime_;
int coreDiskSize_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_

129
hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h Normal file
View File

@@ -0,0 +1,129 @@
/*
* 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_EVALUATEMULTIZONERESOURCEREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_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 EvaluateMultiZoneResourceRequest : public RpcServiceRequest
{
public:
EvaluateMultiZoneResourceRequest();
~EvaluateMultiZoneResourceRequest();
std::string getArchVersion()const;
void setArchVersion(const std::string& archVersion);
std::string getClusterName()const;
void setClusterName(const std::string& clusterName);
std::string getEngineVersion()const;
void setEngineVersion(const std::string& engineVersion);
std::string getLogDiskType()const;
void setLogDiskType(const std::string& logDiskType);
std::string getPrimaryVSwitchId()const;
void setPrimaryVSwitchId(const std::string& primaryVSwitchId);
std::string getLogInstanceType()const;
void setLogInstanceType(const std::string& logInstanceType);
int getAutoRenewPeriod()const;
void setAutoRenewPeriod(int autoRenewPeriod);
int getPeriod()const;
void setPeriod(int period);
int getLogNodeCount()const;
void setLogNodeCount(int logNodeCount);
std::string getSecurityIPList()const;
void setSecurityIPList(const std::string& securityIPList);
std::string getPeriodUnit()const;
void setPeriodUnit(const std::string& periodUnit);
std::string getCoreDiskType()const;
void setCoreDiskType(const std::string& coreDiskType);
std::string getArbiterZoneId()const;
void setArbiterZoneId(const std::string& arbiterZoneId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getMultiZoneCombination()const;
void setMultiZoneCombination(const std::string& multiZoneCombination);
std::string getPrimaryZoneId()const;
void setPrimaryZoneId(const std::string& primaryZoneId);
std::string getEngine()const;
void setEngine(const std::string& engine);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStandbyVSwitchId()const;
void setStandbyVSwitchId(const std::string& standbyVSwitchId);
std::string getStandbyZoneId()const;
void setStandbyZoneId(const std::string& standbyZoneId);
std::string getMasterInstanceType()const;
void setMasterInstanceType(const std::string& masterInstanceType);
int getCoreNodeCount()const;
void setCoreNodeCount(int coreNodeCount);
int getLogDiskSize()const;
void setLogDiskSize(int logDiskSize);
std::string getCoreInstanceType()const;
void setCoreInstanceType(const std::string& coreInstanceType);
int getCoreDiskSize()const;
void setCoreDiskSize(int coreDiskSize);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getArbiterVSwitchId()const;
void setArbiterVSwitchId(const std::string& arbiterVSwitchId);
private:
std::string archVersion_;
std::string clusterName_;
std::string engineVersion_;
std::string logDiskType_;
std::string primaryVSwitchId_;
std::string logInstanceType_;
int autoRenewPeriod_;
int period_;
int logNodeCount_;
std::string securityIPList_;
std::string periodUnit_;
std::string coreDiskType_;
std::string arbiterZoneId_;
std::string clientToken_;
std::string multiZoneCombination_;
std::string primaryZoneId_;
std::string engine_;
std::string regionId_;
std::string standbyVSwitchId_;
std::string standbyZoneId_;
std::string masterInstanceType_;
int coreNodeCount_;
int logDiskSize_;
std::string coreInstanceType_;
int coreDiskSize_;
std::string vpcId_;
std::string payType_;
std::string arbiterVSwitchId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_

51
hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h Normal file
View File

@@ -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_EVALUATEMULTIZONERESOURCERESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_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 EvaluateMultiZoneResourceResult : public ServiceResult
{
public:
EvaluateMultiZoneResourceResult();
explicit EvaluateMultiZoneResourceResult(const std::string &payload);
~EvaluateMultiZoneResourceResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_H_

63
hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* 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_UPGRADEMULTIZONECLUSTERREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_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 UpgradeMultiZoneClusterRequest : public RpcServiceRequest
{
public:
UpgradeMultiZoneClusterRequest();
~UpgradeMultiZoneClusterRequest();
std::string getRunMode()const;
void setRunMode(const std::string& runMode);
std::string getComponents()const;
void setComponents(const std::string& components);
std::string getUpgradeInsName()const;
void setUpgradeInsName(const std::string& upgradeInsName);
std::string getRestartComponents()const;
void setRestartComponents(const std::string& restartComponents);
std::string getClusterId()const;
void setClusterId(const std::string& clusterId);
std::string getVersions()const;
void setVersions(const std::string& versions);
private:
std::string runMode_;
std::string components_;
std::string upgradeInsName_;
std::string restartComponents_;
std::string clusterId_;
std::string versions_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_

51
hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h Normal file
View File

@@ -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_UPGRADEMULTIZONECLUSTERRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_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 UpgradeMultiZoneClusterResult : public ServiceResult
{
public:
UpgradeMultiZoneClusterResult();
explicit UpgradeMultiZoneClusterResult(const std::string &payload);
~UpgradeMultiZoneClusterResult();
std::string getUpgradingComponents()const;
protected:
void parse(const std::string &payload);
private:
std::string upgradingComponents_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_H_

216
hbase/src/HBaseClient.cc
View File

@@ -303,6 +303,42 @@ HBaseClient::CreateRestorePlanOutcomeCallable HBaseClient::createRestorePlanCall
return task->get_future();
}
HBaseClient::DeleteHBaseHaDBOutcome HBaseClient::deleteHBaseHaDB(const DeleteHBaseHaDBRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteHBaseHaDBOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteHBaseHaDBOutcome(DeleteHBaseHaDBResult(outcome.result()));
else
return DeleteHBaseHaDBOutcome(outcome.error());
}
void HBaseClient::deleteHBaseHaDBAsync(const DeleteHBaseHaDBRequest& request, const DeleteHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteHBaseHaDB(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DeleteHBaseHaDBOutcomeCallable HBaseClient::deleteHBaseHaDBCallable(const DeleteHBaseHaDBRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteHBaseHaDBOutcome()>>(
[this, request]()
{
return this->deleteHBaseHaDB(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DeleteHbaseHaSlbOutcome HBaseClient::deleteHbaseHaSlb(const DeleteHbaseHaSlbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +915,114 @@ HBaseClient::DescribeIpWhitelistOutcomeCallable HBaseClient::describeIpWhitelist
return task->get_future();
}
HBaseClient::DescribeMultiZoneAvailableRegionsOutcome HBaseClient::describeMultiZoneAvailableRegions(const DescribeMultiZoneAvailableRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMultiZoneAvailableRegionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMultiZoneAvailableRegionsOutcome(DescribeMultiZoneAvailableRegionsResult(outcome.result()));
else
return DescribeMultiZoneAvailableRegionsOutcome(outcome.error());
}
void HBaseClient::describeMultiZoneAvailableRegionsAsync(const DescribeMultiZoneAvailableRegionsRequest& request, const DescribeMultiZoneAvailableRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMultiZoneAvailableRegions(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DescribeMultiZoneAvailableRegionsOutcomeCallable HBaseClient::describeMultiZoneAvailableRegionsCallable(const DescribeMultiZoneAvailableRegionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMultiZoneAvailableRegionsOutcome()>>(
[this, request]()
{
return this->describeMultiZoneAvailableRegions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DescribeMultiZoneAvailableResourceOutcome HBaseClient::describeMultiZoneAvailableResource(const DescribeMultiZoneAvailableResourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMultiZoneAvailableResourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMultiZoneAvailableResourceOutcome(DescribeMultiZoneAvailableResourceResult(outcome.result()));
else
return DescribeMultiZoneAvailableResourceOutcome(outcome.error());
}
void HBaseClient::describeMultiZoneAvailableResourceAsync(const DescribeMultiZoneAvailableResourceRequest& request, const DescribeMultiZoneAvailableResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMultiZoneAvailableResource(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DescribeMultiZoneAvailableResourceOutcomeCallable HBaseClient::describeMultiZoneAvailableResourceCallable(const DescribeMultiZoneAvailableResourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMultiZoneAvailableResourceOutcome()>>(
[this, request]()
{
return this->describeMultiZoneAvailableResource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DescribeMultiZoneClusterOutcome HBaseClient::describeMultiZoneCluster(const DescribeMultiZoneClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMultiZoneClusterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMultiZoneClusterOutcome(DescribeMultiZoneClusterResult(outcome.result()));
else
return DescribeMultiZoneClusterOutcome(outcome.error());
}
void HBaseClient::describeMultiZoneClusterAsync(const DescribeMultiZoneClusterRequest& request, const DescribeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMultiZoneCluster(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DescribeMultiZoneClusterOutcomeCallable HBaseClient::describeMultiZoneClusterCallable(const DescribeMultiZoneClusterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMultiZoneClusterOutcome()>>(
[this, request]()
{
return this->describeMultiZoneCluster(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DescribeRecoverableTimeRangeOutcome HBaseClient::describeRecoverableTimeRange(const DescribeRecoverableTimeRangeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1383,42 @@ HBaseClient::EnableHBaseueModuleOutcomeCallable HBaseClient::enableHBaseueModule
return task->get_future();
}
HBaseClient::EvaluateMultiZoneResourceOutcome HBaseClient::evaluateMultiZoneResource(const EvaluateMultiZoneResourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EvaluateMultiZoneResourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EvaluateMultiZoneResourceOutcome(EvaluateMultiZoneResourceResult(outcome.result()));
else
return EvaluateMultiZoneResourceOutcome(outcome.error());
}
void HBaseClient::evaluateMultiZoneResourceAsync(const EvaluateMultiZoneResourceRequest& request, const EvaluateMultiZoneResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, evaluateMultiZoneResource(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::EvaluateMultiZoneResourceOutcomeCallable HBaseClient::evaluateMultiZoneResourceCallable(const EvaluateMultiZoneResourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EvaluateMultiZoneResourceOutcome()>>(
[this, request]()
{
return this->evaluateMultiZoneResource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1923,6 +2103,42 @@ HBaseClient::UnTagResourcesOutcomeCallable HBaseClient::unTagResourcesCallable(c
return task->get_future();
}
HBaseClient::UpgradeMultiZoneClusterOutcome HBaseClient::upgradeMultiZoneCluster(const UpgradeMultiZoneClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpgradeMultiZoneClusterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpgradeMultiZoneClusterOutcome(UpgradeMultiZoneClusterResult(outcome.result()));
else
return UpgradeMultiZoneClusterOutcome(outcome.error());
}
void HBaseClient::upgradeMultiZoneClusterAsync(const UpgradeMultiZoneClusterRequest& request, const UpgradeMultiZoneClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, upgradeMultiZoneCluster(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::UpgradeMultiZoneClusterOutcomeCallable HBaseClient::upgradeMultiZoneClusterCallable(const UpgradeMultiZoneClusterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpgradeMultiZoneClusterOutcome()>>(
[this, request]()
{
return this->upgradeMultiZoneCluster(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::XpackRelateDBOutcome HBaseClient::xpackRelateDB(const XpackRelateDBRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

51
hbase/src/model/DeleteHBaseHaDBRequest.cc Normal file
View File

@@ -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/DeleteHBaseHaDBRequest.h>
using AlibabaCloud::HBase::Model::DeleteHBaseHaDBRequest;
DeleteHBaseHaDBRequest::DeleteHBaseHaDBRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DeleteHBaseHaDB")
{
setMethod(HttpRequest::Method::Post);
}
DeleteHBaseHaDBRequest::~DeleteHBaseHaDBRequest()
{}
std::string DeleteHBaseHaDBRequest::getHaId()const
{
return haId_;
}
void DeleteHBaseHaDBRequest::setHaId(const std::string& haId)
{
haId_ = haId;
setParameter("HaId", haId);
}
std::string DeleteHBaseHaDBRequest::getBdsId()const
{
return bdsId_;
}
void DeleteHBaseHaDBRequest::setBdsId(const std::string& bdsId)
{
bdsId_ = bdsId;
setParameter("BdsId", bdsId);
}

44
hbase/src/model/DeleteHBaseHaDBResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/DeleteHBaseHaDBResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DeleteHBaseHaDBResult::DeleteHBaseHaDBResult() :
ServiceResult()
{}
DeleteHBaseHaDBResult::DeleteHBaseHaDBResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteHBaseHaDBResult::~DeleteHBaseHaDBResult()
{}
void DeleteHBaseHaDBResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

40
hbase/src/model/DescribeMultiZoneAvailableRegionsRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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/DescribeMultiZoneAvailableRegionsRequest.h>
using AlibabaCloud::HBase::Model::DescribeMultiZoneAvailableRegionsRequest;
DescribeMultiZoneAvailableRegionsRequest::DescribeMultiZoneAvailableRegionsRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneAvailableRegions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeMultiZoneAvailableRegionsRequest::~DescribeMultiZoneAvailableRegionsRequest()
{}
std::string DescribeMultiZoneAvailableRegionsRequest::getAcceptLanguage()const
{
return acceptLanguage_;
}
void DescribeMultiZoneAvailableRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
{
acceptLanguage_ = acceptLanguage;
setParameter("AcceptLanguage", acceptLanguage);
}

72
hbase/src/model/DescribeMultiZoneAvailableRegionsResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* 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/DescribeMultiZoneAvailableRegionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DescribeMultiZoneAvailableRegionsResult::DescribeMultiZoneAvailableRegionsResult() :
ServiceResult()
{}
DescribeMultiZoneAvailableRegionsResult::DescribeMultiZoneAvailableRegionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMultiZoneAvailableRegionsResult::~DescribeMultiZoneAvailableRegionsResult()
{}
void DescribeMultiZoneAvailableRegionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRegionsNode = value["Regions"]["Region"];
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
if(!valueRegionsRegion["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
auto allAvailableCombinesNode = allRegionsNode["AvailableCombines"]["AvailableCombine"];
for (auto allRegionsNodeAvailableCombinesAvailableCombine : allAvailableCombinesNode)
{
Region::AvailableCombine availableCombinesObject;
if(!allRegionsNodeAvailableCombinesAvailableCombine["Id"].isNull())
availableCombinesObject.id = allRegionsNodeAvailableCombinesAvailableCombine["Id"].asString();
auto allZones = value["Zones"]["Zone"];
for (auto value : allZones)
availableCombinesObject.zones.push_back(value.asString());
regionsObject.availableCombines.push_back(availableCombinesObject);
}
regions_.push_back(regionsObject);
}
}
std::vector<DescribeMultiZoneAvailableRegionsResult::Region> DescribeMultiZoneAvailableRegionsResult::getRegions()const
{
return regions_;
}

62
hbase/src/model/DescribeMultiZoneAvailableResourceRequest.cc Normal file
View File

@@ -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/DescribeMultiZoneAvailableResourceRequest.h>
using AlibabaCloud::HBase::Model::DescribeMultiZoneAvailableResourceRequest;
DescribeMultiZoneAvailableResourceRequest::DescribeMultiZoneAvailableResourceRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneAvailableResource")
{
setMethod(HttpRequest::Method::Post);
}
DescribeMultiZoneAvailableResourceRequest::~DescribeMultiZoneAvailableResourceRequest()
{}
std::string DescribeMultiZoneAvailableResourceRequest::getZoneCombination()const
{
return zoneCombination_;
}
void DescribeMultiZoneAvailableResourceRequest::setZoneCombination(const std::string& zoneCombination)
{
zoneCombination_ = zoneCombination;
setParameter("ZoneCombination", zoneCombination);
}
std::string DescribeMultiZoneAvailableResourceRequest::getRegionId()const
{
return regionId_;
}
void DescribeMultiZoneAvailableResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeMultiZoneAvailableResourceRequest::getChargeType()const
{
return chargeType_;
}
void DescribeMultiZoneAvailableResourceRequest::setChargeType(const std::string& chargeType)
{
chargeType_ = chargeType;
setParameter("ChargeType", chargeType);
}

126
hbase/src/model/DescribeMultiZoneAvailableResourceResult.cc Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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/DescribeMultiZoneAvailableResourceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DescribeMultiZoneAvailableResourceResult::DescribeMultiZoneAvailableResourceResult() :
ServiceResult()
{}
DescribeMultiZoneAvailableResourceResult::DescribeMultiZoneAvailableResourceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMultiZoneAvailableResourceResult::~DescribeMultiZoneAvailableResourceResult()
{}
void DescribeMultiZoneAvailableResourceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAvailableZonesNode = value["AvailableZones"]["AvailableZone"];
for (auto valueAvailableZonesAvailableZone : allAvailableZonesNode)
{
AvailableZone availableZonesObject;
if(!valueAvailableZonesAvailableZone["RegionId"].isNull())
availableZonesObject.regionId = valueAvailableZonesAvailableZone["RegionId"].asString();
if(!valueAvailableZonesAvailableZone["ZoneCombination"].isNull())
availableZonesObject.zoneCombination = valueAvailableZonesAvailableZone["ZoneCombination"].asString();
auto allMasterResourcesNode = allAvailableZonesNode["MasterResources"]["MasterResource"];
for (auto allAvailableZonesNodeMasterResourcesMasterResource : allMasterResourcesNode)
{
AvailableZone::MasterResource masterResourcesObject;
if(!allAvailableZonesNodeMasterResourcesMasterResource["InstanceType"].isNull())
masterResourcesObject.instanceType = allAvailableZonesNodeMasterResourcesMasterResource["InstanceType"].asString();
auto instanceTypeDetailNode = value["InstanceTypeDetail"];
if(!instanceTypeDetailNode["Cpu"].isNull())
masterResourcesObject.instanceTypeDetail.cpu = std::stoi(instanceTypeDetailNode["Cpu"].asString());
if(!instanceTypeDetailNode["Mem"].isNull())
masterResourcesObject.instanceTypeDetail.mem = std::stoi(instanceTypeDetailNode["Mem"].asString());
availableZonesObject.masterResources.push_back(masterResourcesObject);
}
auto allSupportedEnginesNode = allAvailableZonesNode["SupportedEngines"]["SupportedEngine"];
for (auto allAvailableZonesNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
{
AvailableZone::SupportedEngine supportedEnginesObject;
if(!allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].isNull())
supportedEnginesObject.engine = allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].asString();
auto allSupportedEngineVersionsNode = allSupportedEnginesNode["SupportedEngineVersions"]["SupportedEngineVersion"];
for (auto allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
{
AvailableZone::SupportedEngine::SupportedEngineVersion supportedEngineVersionsObject;
if(!allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
supportedEngineVersionsObject.version = allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
auto allSupportedCategoriesNode = allSupportedEngineVersionsNode["SupportedCategories"]["SupportedCategoriesItem"];
for (auto allSupportedEngineVersionsNodeSupportedCategoriesSupportedCategoriesItem : allSupportedCategoriesNode)
{
AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem supportedCategoriesObject;
if(!allSupportedEngineVersionsNodeSupportedCategoriesSupportedCategoriesItem["Category"].isNull())
supportedCategoriesObject.category = allSupportedEngineVersionsNodeSupportedCategoriesSupportedCategoriesItem["Category"].asString();
auto allSupportedStorageTypesNode = allSupportedCategoriesNode["SupportedStorageTypes"]["SupportedStorageType"];
for (auto allSupportedCategoriesNodeSupportedStorageTypesSupportedStorageType : allSupportedStorageTypesNode)
{
AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem::SupportedStorageType supportedStorageTypesObject;
if(!allSupportedCategoriesNodeSupportedStorageTypesSupportedStorageType["StorageType"].isNull())
supportedStorageTypesObject.storageType = allSupportedCategoriesNodeSupportedStorageTypesSupportedStorageType["StorageType"].asString();
auto allCoreResourcesNode = allSupportedStorageTypesNode["CoreResources"]["CoreResource"];
for (auto allSupportedStorageTypesNodeCoreResourcesCoreResource : allCoreResourcesNode)
{
AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategoriesItem::SupportedStorageType::CoreResource coreResourcesObject;
if(!allSupportedStorageTypesNodeCoreResourcesCoreResource["InstanceType"].isNull())
coreResourcesObject.instanceType = allSupportedStorageTypesNodeCoreResourcesCoreResource["InstanceType"].asString();
if(!allSupportedStorageTypesNodeCoreResourcesCoreResource["MaxCoreCount"].isNull())
coreResourcesObject.maxCoreCount = std::stoi(allSupportedStorageTypesNodeCoreResourcesCoreResource["MaxCoreCount"].asString());
auto dBInstanceStorageRangeNode = value["DBInstanceStorageRange"];
if(!dBInstanceStorageRangeNode["MaxSize"].isNull())
coreResourcesObject.dBInstanceStorageRange.maxSize = std::stoi(dBInstanceStorageRangeNode["MaxSize"].asString());
if(!dBInstanceStorageRangeNode["MinSize"].isNull())
coreResourcesObject.dBInstanceStorageRange.minSize = std::stoi(dBInstanceStorageRangeNode["MinSize"].asString());
if(!dBInstanceStorageRangeNode["StepSize"].isNull())
coreResourcesObject.dBInstanceStorageRange.stepSize = std::stoi(dBInstanceStorageRangeNode["StepSize"].asString());
auto instanceTypeDetail1Node = value["InstanceTypeDetail"];
if(!instanceTypeDetail1Node["Cpu"].isNull())
coreResourcesObject.instanceTypeDetail1.cpu = std::stoi(instanceTypeDetail1Node["Cpu"].asString());
if(!instanceTypeDetail1Node["Mem"].isNull())
coreResourcesObject.instanceTypeDetail1.mem = std::stoi(instanceTypeDetail1Node["Mem"].asString());
supportedStorageTypesObject.coreResources.push_back(coreResourcesObject);
}
supportedCategoriesObject.supportedStorageTypes.push_back(supportedStorageTypesObject);
}
supportedEngineVersionsObject.supportedCategories.push_back(supportedCategoriesObject);
}
supportedEnginesObject.supportedEngineVersions.push_back(supportedEngineVersionsObject);
}
availableZonesObject.supportedEngines.push_back(supportedEnginesObject);
}
availableZones_.push_back(availableZonesObject);
}
}
std::vector<DescribeMultiZoneAvailableResourceResult::AvailableZone> DescribeMultiZoneAvailableResourceResult::getAvailableZones()const
{
return availableZones_;
}

40
hbase/src/model/DescribeMultiZoneClusterRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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/DescribeMultiZoneClusterRequest.h>
using AlibabaCloud::HBase::Model::DescribeMultiZoneClusterRequest;
DescribeMultiZoneClusterRequest::DescribeMultiZoneClusterRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneCluster")
{
setMethod(HttpRequest::Method::Post);
}
DescribeMultiZoneClusterRequest::~DescribeMultiZoneClusterRequest()
{}
std::string DescribeMultiZoneClusterRequest::getClusterId()const
{
return clusterId_;
}
void DescribeMultiZoneClusterRequest::setClusterId(const std::string& clusterId)
{
clusterId_ = clusterId;
setParameter("ClusterId", clusterId);
}

388
hbase/src/model/DescribeMultiZoneClusterResult.cc Normal file
View File

@@ -0,0 +1,388 @@
/*
* 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/DescribeMultiZoneClusterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DescribeMultiZoneClusterResult::DescribeMultiZoneClusterResult() :
ServiceResult()
{}
DescribeMultiZoneClusterResult::DescribeMultiZoneClusterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMultiZoneClusterResult::~DescribeMultiZoneClusterResult()
{}
void DescribeMultiZoneClusterResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMultiZoneInstanceModelsNode = value["MultiZoneInstanceModels"]["MultiZoneInstanceModel"];
for (auto valueMultiZoneInstanceModelsMultiZoneInstanceModel : allMultiZoneInstanceModelsNode)
{
MultiZoneInstanceModel multiZoneInstanceModelsObject;
if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["InsName"].isNull())
multiZoneInstanceModelsObject.insName = valueMultiZoneInstanceModelsMultiZoneInstanceModel["InsName"].asString();
if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["IsLatestVersion"].isNull())
multiZoneInstanceModelsObject.isLatestVersion = valueMultiZoneInstanceModelsMultiZoneInstanceModel["IsLatestVersion"].asString() == "true";
if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["MinorVersion"].isNull())
multiZoneInstanceModelsObject.minorVersion = valueMultiZoneInstanceModelsMultiZoneInstanceModel["MinorVersion"].asString();
if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["Status"].isNull())
multiZoneInstanceModelsObject.status = valueMultiZoneInstanceModelsMultiZoneInstanceModel["Status"].asString();
if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["Role"].isNull())
multiZoneInstanceModelsObject.role = valueMultiZoneInstanceModelsMultiZoneInstanceModel["Role"].asString();
multiZoneInstanceModels_.push_back(multiZoneInstanceModelsObject);
}
auto allTagsNode = value["Tags"]["Tag"];
for (auto valueTagsTag : allTagsNode)
{
Tag tagsObject;
if(!valueTagsTag["Key"].isNull())
tagsObject.key = valueTagsTag["Key"].asString();
if(!valueTagsTag["Value"].isNull())
tagsObject.value = valueTagsTag["Value"].asString();
tags_.push_back(tagsObject);
}
if(!value["AutoRenewal"].isNull())
autoRenewal_ = value["AutoRenewal"].asString() == "true";
if(!value["ClusterId"].isNull())
clusterId_ = value["ClusterId"].asString();
if(!value["ClusterName"].isNull())
clusterName_ = value["ClusterName"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["CreatedTimeUTC"].isNull())
createdTimeUTC_ = value["CreatedTimeUTC"].asString();
if(!value["Duration"].isNull())
duration_ = std::stoi(value["Duration"].asString());
if(!value["Engine"].isNull())
engine_ = value["Engine"].asString();
if(!value["ExpireTime"].isNull())
expireTime_ = value["ExpireTime"].asString();
if(!value["ExpireTimeUTC"].isNull())
expireTimeUTC_ = value["ExpireTimeUTC"].asString();
if(!value["InstanceId"].isNull())
instanceId_ = value["InstanceId"].asString();
if(!value["InstanceName"].isNull())
instanceName_ = value["InstanceName"].asString();
if(!value["IsDeletionProtection"].isNull())
isDeletionProtection_ = value["IsDeletionProtection"].asString() == "true";
if(!value["MaintainEndTime"].isNull())
maintainEndTime_ = value["MaintainEndTime"].asString();
if(!value["MaintainStartTime"].isNull())
maintainStartTime_ = value["MaintainStartTime"].asString();
if(!value["MajorVersion"].isNull())
majorVersion_ = value["MajorVersion"].asString();
if(!value["MasterDiskSize"].isNull())
masterDiskSize_ = std::stoi(value["MasterDiskSize"].asString());
if(!value["MasterDiskType"].isNull())
masterDiskType_ = value["MasterDiskType"].asString();
if(!value["MasterInstanceType"].isNull())
masterInstanceType_ = value["MasterInstanceType"].asString();
if(!value["MasterNodeCount"].isNull())
masterNodeCount_ = std::stoi(value["MasterNodeCount"].asString());
if(!value["CoreDiskCount"].isNull())
coreDiskCount_ = value["CoreDiskCount"].asString();
if(!value["CoreDiskSize"].isNull())
coreDiskSize_ = std::stoi(value["CoreDiskSize"].asString());
if(!value["CoreDiskType"].isNull())
coreDiskType_ = value["CoreDiskType"].asString();
if(!value["CoreInstanceType"].isNull())
coreInstanceType_ = value["CoreInstanceType"].asString();
if(!value["CoreNodeCount"].isNull())
coreNodeCount_ = std::stoi(value["CoreNodeCount"].asString());
if(!value["LogDiskCount"].isNull())
logDiskCount_ = value["LogDiskCount"].asString();
if(!value["LogDiskSize"].isNull())
logDiskSize_ = std::stoi(value["LogDiskSize"].asString());
if(!value["LogDiskType"].isNull())
logDiskType_ = value["LogDiskType"].asString();
if(!value["LogInstanceType"].isNull())
logInstanceType_ = value["LogInstanceType"].asString();
if(!value["LogNodeCount"].isNull())
logNodeCount_ = std::stoi(value["LogNodeCount"].asString());
if(!value["ModuleId"].isNull())
moduleId_ = std::stoi(value["ModuleId"].asString());
if(!value["ModuleStackVersion"].isNull())
moduleStackVersion_ = value["ModuleStackVersion"].asString();
if(!value["NetworkType"].isNull())
networkType_ = value["NetworkType"].asString();
if(!value["ParentId"].isNull())
parentId_ = value["ParentId"].asString();
if(!value["PayType"].isNull())
payType_ = value["PayType"].asString();
if(!value["RegionId"].isNull())
regionId_ = value["RegionId"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["MultiZoneCombination"].isNull())
multiZoneCombination_ = value["MultiZoneCombination"].asString();
if(!value["PrimaryZoneId"].isNull())
primaryZoneId_ = value["PrimaryZoneId"].asString();
if(!value["PrimaryVSwitchIds"].isNull())
primaryVSwitchIds_ = value["PrimaryVSwitchIds"].asString();
if(!value["StandbyZoneId"].isNull())
standbyZoneId_ = value["StandbyZoneId"].asString();
if(!value["StandbyVSwitchIds"].isNull())
standbyVSwitchIds_ = value["StandbyVSwitchIds"].asString();
if(!value["ArbiterZoneId"].isNull())
arbiterZoneId_ = value["ArbiterZoneId"].asString();
if(!value["ArbiterVSwitchIds"].isNull())
arbiterVSwitchIds_ = value["ArbiterVSwitchIds"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
}
std::string DescribeMultiZoneClusterResult::getModuleStackVersion()const
{
return moduleStackVersion_;
}
std::string DescribeMultiZoneClusterResult::getStandbyZoneId()const
{
return standbyZoneId_;
}
std::string DescribeMultiZoneClusterResult::getCreatedTime()const
{
return createdTime_;
}
std::string DescribeMultiZoneClusterResult::getMasterInstanceType()const
{
return masterInstanceType_;
}
std::string DescribeMultiZoneClusterResult::getPrimaryVSwitchIds()const
{
return primaryVSwitchIds_;
}
bool DescribeMultiZoneClusterResult::getIsDeletionProtection()const
{
return isDeletionProtection_;
}
std::string DescribeMultiZoneClusterResult::getLogDiskCount()const
{
return logDiskCount_;
}
int DescribeMultiZoneClusterResult::getLogDiskSize()const
{
return logDiskSize_;
}
int DescribeMultiZoneClusterResult::getModuleId()const
{
return moduleId_;
}
std::string DescribeMultiZoneClusterResult::getArbiterVSwitchIds()const
{
return arbiterVSwitchIds_;
}
std::string DescribeMultiZoneClusterResult::getMaintainEndTime()const
{
return maintainEndTime_;
}
std::string DescribeMultiZoneClusterResult::getStandbyVSwitchIds()const
{
return standbyVSwitchIds_;
}
std::string DescribeMultiZoneClusterResult::getNetworkType()const
{
return networkType_;
}
std::string DescribeMultiZoneClusterResult::getCoreInstanceType()const
{
return coreInstanceType_;
}
std::string DescribeMultiZoneClusterResult::getClusterName()const
{
return clusterName_;
}
std::string DescribeMultiZoneClusterResult::getMasterDiskType()const
{
return masterDiskType_;
}
std::vector<DescribeMultiZoneClusterResult::Tag> DescribeMultiZoneClusterResult::getTags()const
{
return tags_;
}
std::string DescribeMultiZoneClusterResult::getEngine()const
{
return engine_;
}
std::string DescribeMultiZoneClusterResult::getMaintainStartTime()const
{
return maintainStartTime_;
}
std::string DescribeMultiZoneClusterResult::getArbiterZoneId()const
{
return arbiterZoneId_;
}
std::string DescribeMultiZoneClusterResult::getMajorVersion()const
{
return majorVersion_;
}
std::string DescribeMultiZoneClusterResult::getCoreDiskCount()const
{
return coreDiskCount_;
}
std::string DescribeMultiZoneClusterResult::getParentId()const
{
return parentId_;
}
std::string DescribeMultiZoneClusterResult::getStatus()const
{
return status_;
}
std::vector<DescribeMultiZoneClusterResult::MultiZoneInstanceModel> DescribeMultiZoneClusterResult::getMultiZoneInstanceModels()const
{
return multiZoneInstanceModels_;
}
std::string DescribeMultiZoneClusterResult::getExpireTimeUTC()const
{
return expireTimeUTC_;
}
int DescribeMultiZoneClusterResult::getMasterDiskSize()const
{
return masterDiskSize_;
}
std::string DescribeMultiZoneClusterResult::getPrimaryZoneId()const
{
return primaryZoneId_;
}
std::string DescribeMultiZoneClusterResult::getMultiZoneCombination()const
{
return multiZoneCombination_;
}
std::string DescribeMultiZoneClusterResult::getClusterId()const
{
return clusterId_;
}
std::string DescribeMultiZoneClusterResult::getInstanceId()const
{
return instanceId_;
}
int DescribeMultiZoneClusterResult::getCoreNodeCount()const
{
return coreNodeCount_;
}
std::string DescribeMultiZoneClusterResult::getCreatedTimeUTC()const
{
return createdTimeUTC_;
}
int DescribeMultiZoneClusterResult::getDuration()const
{
return duration_;
}
std::string DescribeMultiZoneClusterResult::getLogInstanceType()const
{
return logInstanceType_;
}
std::string DescribeMultiZoneClusterResult::getPayType()const
{
return payType_;
}
std::string DescribeMultiZoneClusterResult::getInstanceName()const
{
return instanceName_;
}
int DescribeMultiZoneClusterResult::getMasterNodeCount()const
{
return masterNodeCount_;
}
bool DescribeMultiZoneClusterResult::getAutoRenewal()const
{
return autoRenewal_;
}
std::string DescribeMultiZoneClusterResult::getVpcId()const
{
return vpcId_;
}
std::string DescribeMultiZoneClusterResult::getCoreDiskType()const
{
return coreDiskType_;
}
int DescribeMultiZoneClusterResult::getLogNodeCount()const
{
return logNodeCount_;
}
std::string DescribeMultiZoneClusterResult::getLogDiskType()const
{
return logDiskType_;
}
std::string DescribeMultiZoneClusterResult::getRegionId()const
{
return regionId_;
}
std::string DescribeMultiZoneClusterResult::getExpireTime()const
{
return expireTime_;
}
int DescribeMultiZoneClusterResult::getCoreDiskSize()const
{
return coreDiskSize_;
}

337
hbase/src/model/EvaluateMultiZoneResourceRequest.cc Normal file
View File

@@ -0,0 +1,337 @@
/*
* 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/EvaluateMultiZoneResourceRequest.h>
using AlibabaCloud::HBase::Model::EvaluateMultiZoneResourceRequest;
EvaluateMultiZoneResourceRequest::EvaluateMultiZoneResourceRequest() :
RpcServiceRequest("hbase", "2019-01-01", "EvaluateMultiZoneResource")
{
setMethod(HttpRequest::Method::Post);
}
EvaluateMultiZoneResourceRequest::~EvaluateMultiZoneResourceRequest()
{}
std::string EvaluateMultiZoneResourceRequest::getArchVersion()const
{
return archVersion_;
}
void EvaluateMultiZoneResourceRequest::setArchVersion(const std::string& archVersion)
{
archVersion_ = archVersion;
setParameter("ArchVersion", archVersion);
}
std::string EvaluateMultiZoneResourceRequest::getClusterName()const
{
return clusterName_;
}
void EvaluateMultiZoneResourceRequest::setClusterName(const std::string& clusterName)
{
clusterName_ = clusterName;
setParameter("ClusterName", clusterName);
}
std::string EvaluateMultiZoneResourceRequest::getEngineVersion()const
{
return engineVersion_;
}
void EvaluateMultiZoneResourceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string EvaluateMultiZoneResourceRequest::getLogDiskType()const
{
return logDiskType_;
}
void EvaluateMultiZoneResourceRequest::setLogDiskType(const std::string& logDiskType)
{
logDiskType_ = logDiskType;
setParameter("LogDiskType", logDiskType);
}
std::string EvaluateMultiZoneResourceRequest::getPrimaryVSwitchId()const
{
return primaryVSwitchId_;
}
void EvaluateMultiZoneResourceRequest::setPrimaryVSwitchId(const std::string& primaryVSwitchId)
{
primaryVSwitchId_ = primaryVSwitchId;
setParameter("PrimaryVSwitchId", primaryVSwitchId);
}
std::string EvaluateMultiZoneResourceRequest::getLogInstanceType()const
{
return logInstanceType_;
}
void EvaluateMultiZoneResourceRequest::setLogInstanceType(const std::string& logInstanceType)
{
logInstanceType_ = logInstanceType;
setParameter("LogInstanceType", logInstanceType);
}
int EvaluateMultiZoneResourceRequest::getAutoRenewPeriod()const
{
return autoRenewPeriod_;
}
void EvaluateMultiZoneResourceRequest::setAutoRenewPeriod(int autoRenewPeriod)
{
autoRenewPeriod_ = autoRenewPeriod;
setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
}
int EvaluateMultiZoneResourceRequest::getPeriod()const
{
return period_;
}
void EvaluateMultiZoneResourceRequest::setPeriod(int period)
{
period_ = period;
setParameter("Period", std::to_string(period));
}
int EvaluateMultiZoneResourceRequest::getLogNodeCount()const
{
return logNodeCount_;
}
void EvaluateMultiZoneResourceRequest::setLogNodeCount(int logNodeCount)
{
logNodeCount_ = logNodeCount;
setParameter("LogNodeCount", std::to_string(logNodeCount));
}
std::string EvaluateMultiZoneResourceRequest::getSecurityIPList()const
{
return securityIPList_;
}
void EvaluateMultiZoneResourceRequest::setSecurityIPList(const std::string& securityIPList)
{
securityIPList_ = securityIPList;
setParameter("SecurityIPList", securityIPList);
}
std::string EvaluateMultiZoneResourceRequest::getPeriodUnit()const
{
return periodUnit_;
}
void EvaluateMultiZoneResourceRequest::setPeriodUnit(const std::string& periodUnit)
{
periodUnit_ = periodUnit;
setParameter("PeriodUnit", periodUnit);
}
std::string EvaluateMultiZoneResourceRequest::getCoreDiskType()const
{
return coreDiskType_;
}
void EvaluateMultiZoneResourceRequest::setCoreDiskType(const std::string& coreDiskType)
{
coreDiskType_ = coreDiskType;
setParameter("CoreDiskType", coreDiskType);
}
std::string EvaluateMultiZoneResourceRequest::getArbiterZoneId()const
{
return arbiterZoneId_;
}
void EvaluateMultiZoneResourceRequest::setArbiterZoneId(const std::string& arbiterZoneId)
{
arbiterZoneId_ = arbiterZoneId;
setParameter("ArbiterZoneId", arbiterZoneId);
}
std::string EvaluateMultiZoneResourceRequest::getClientToken()const
{
return clientToken_;
}
void EvaluateMultiZoneResourceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string EvaluateMultiZoneResourceRequest::getMultiZoneCombination()const
{
return multiZoneCombination_;
}
void EvaluateMultiZoneResourceRequest::setMultiZoneCombination(const std::string& multiZoneCombination)
{
multiZoneCombination_ = multiZoneCombination;
setParameter("MultiZoneCombination", multiZoneCombination);
}
std::string EvaluateMultiZoneResourceRequest::getPrimaryZoneId()const
{
return primaryZoneId_;
}
void EvaluateMultiZoneResourceRequest::setPrimaryZoneId(const std::string& primaryZoneId)
{
primaryZoneId_ = primaryZoneId;
setParameter("PrimaryZoneId", primaryZoneId);
}
std::string EvaluateMultiZoneResourceRequest::getEngine()const
{
return engine_;
}
void EvaluateMultiZoneResourceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string EvaluateMultiZoneResourceRequest::getRegionId()const
{
return regionId_;
}
void EvaluateMultiZoneResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string EvaluateMultiZoneResourceRequest::getStandbyVSwitchId()const
{
return standbyVSwitchId_;
}
void EvaluateMultiZoneResourceRequest::setStandbyVSwitchId(const std::string& standbyVSwitchId)
{
standbyVSwitchId_ = standbyVSwitchId;
setParameter("StandbyVSwitchId", standbyVSwitchId);
}
std::string EvaluateMultiZoneResourceRequest::getStandbyZoneId()const
{
return standbyZoneId_;
}
void EvaluateMultiZoneResourceRequest::setStandbyZoneId(const std::string& standbyZoneId)
{
standbyZoneId_ = standbyZoneId;
setParameter("StandbyZoneId", standbyZoneId);
}
std::string EvaluateMultiZoneResourceRequest::getMasterInstanceType()const
{
return masterInstanceType_;
}
void EvaluateMultiZoneResourceRequest::setMasterInstanceType(const std::string& masterInstanceType)
{
masterInstanceType_ = masterInstanceType;
setParameter("MasterInstanceType", masterInstanceType);
}
int EvaluateMultiZoneResourceRequest::getCoreNodeCount()const
{
return coreNodeCount_;
}
void EvaluateMultiZoneResourceRequest::setCoreNodeCount(int coreNodeCount)
{
coreNodeCount_ = coreNodeCount;
setParameter("CoreNodeCount", std::to_string(coreNodeCount));
}
int EvaluateMultiZoneResourceRequest::getLogDiskSize()const
{
return logDiskSize_;
}
void EvaluateMultiZoneResourceRequest::setLogDiskSize(int logDiskSize)
{
logDiskSize_ = logDiskSize;
setParameter("LogDiskSize", std::to_string(logDiskSize));
}
std::string EvaluateMultiZoneResourceRequest::getCoreInstanceType()const
{
return coreInstanceType_;
}
void EvaluateMultiZoneResourceRequest::setCoreInstanceType(const std::string& coreInstanceType)
{
coreInstanceType_ = coreInstanceType;
setParameter("CoreInstanceType", coreInstanceType);
}
int EvaluateMultiZoneResourceRequest::getCoreDiskSize()const
{
return coreDiskSize_;
}
void EvaluateMultiZoneResourceRequest::setCoreDiskSize(int coreDiskSize)
{
coreDiskSize_ = coreDiskSize;
setParameter("CoreDiskSize", std::to_string(coreDiskSize));
}
std::string EvaluateMultiZoneResourceRequest::getVpcId()const
{
return vpcId_;
}
void EvaluateMultiZoneResourceRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setParameter("VpcId", vpcId);
}
std::string EvaluateMultiZoneResourceRequest::getPayType()const
{
return payType_;
}
void EvaluateMultiZoneResourceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string EvaluateMultiZoneResourceRequest::getArbiterVSwitchId()const
{
return arbiterVSwitchId_;
}
void EvaluateMultiZoneResourceRequest::setArbiterVSwitchId(const std::string& arbiterVSwitchId)
{
arbiterVSwitchId_ = arbiterVSwitchId;
setParameter("ArbiterVSwitchId", arbiterVSwitchId);
}

51
hbase/src/model/EvaluateMultiZoneResourceResult.cc Normal file
View File

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

95
hbase/src/model/UpgradeMultiZoneClusterRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/UpgradeMultiZoneClusterRequest.h>
using AlibabaCloud::HBase::Model::UpgradeMultiZoneClusterRequest;
UpgradeMultiZoneClusterRequest::UpgradeMultiZoneClusterRequest() :
RpcServiceRequest("hbase", "2019-01-01", "UpgradeMultiZoneCluster")
{
setMethod(HttpRequest::Method::Post);
}
UpgradeMultiZoneClusterRequest::~UpgradeMultiZoneClusterRequest()
{}
std::string UpgradeMultiZoneClusterRequest::getRunMode()const
{
return runMode_;
}
void UpgradeMultiZoneClusterRequest::setRunMode(const std::string& runMode)
{
runMode_ = runMode;
setParameter("RunMode", runMode);
}
std::string UpgradeMultiZoneClusterRequest::getComponents()const
{
return components_;
}
void UpgradeMultiZoneClusterRequest::setComponents(const std::string& components)
{
components_ = components;
setParameter("Components", components);
}
std::string UpgradeMultiZoneClusterRequest::getUpgradeInsName()const
{
return upgradeInsName_;
}
void UpgradeMultiZoneClusterRequest::setUpgradeInsName(const std::string& upgradeInsName)
{
upgradeInsName_ = upgradeInsName;
setParameter("UpgradeInsName", upgradeInsName);
}
std::string UpgradeMultiZoneClusterRequest::getRestartComponents()const
{
return restartComponents_;
}
void UpgradeMultiZoneClusterRequest::setRestartComponents(const std::string& restartComponents)
{
restartComponents_ = restartComponents;
setParameter("RestartComponents", restartComponents);
}
std::string UpgradeMultiZoneClusterRequest::getClusterId()const
{
return clusterId_;
}
void UpgradeMultiZoneClusterRequest::setClusterId(const std::string& clusterId)
{
clusterId_ = clusterId;
setParameter("ClusterId", clusterId);
}
std::string UpgradeMultiZoneClusterRequest::getVersions()const
{
return versions_;
}
void UpgradeMultiZoneClusterRequest::setVersions(const std::string& versions)
{
versions_ = versions;
setParameter("Versions", versions);
}

51
hbase/src/model/UpgradeMultiZoneClusterResult.cc Normal file
View File

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