diff --git a/CHANGELOG b/CHANGELOG index f7179c787..8efc98830 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -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. diff --git a/VERSION b/VERSION index 51df198bb..d1a0bc42b 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.597 \ No newline at end of file +1.36.598 \ No newline at end of file diff --git a/hbase/CMakeLists.txt b/hbase/CMakeLists.txt index 01c25665f..bb2f54b3c 100644 --- a/hbase/CMakeLists.txt +++ b/hbase/CMakeLists.txt @@ -35,6 +35,8 @@ set(hbase_public_header_model include/alibabacloud/hbase/model/CreateMultiZoneClusterResult.h include/alibabacloud/hbase/model/CreateRestorePlanRequest.h include/alibabacloud/hbase/model/CreateRestorePlanResult.h + include/alibabacloud/hbase/model/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 ) diff --git a/hbase/include/alibabacloud/hbase/HBaseClient.h b/hbase/include/alibabacloud/hbase/HBaseClient.h index a38f3f314..509e22e44 100644 --- a/hbase/include/alibabacloud/hbase/HBaseClient.h +++ b/hbase/include/alibabacloud/hbase/HBaseClient.h @@ -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 CreateRestorePlanOutcome; typedef std::future CreateRestorePlanOutcomeCallable; typedef std::function&)> CreateRestorePlanAsyncHandler; + typedef Outcome DeleteHBaseHaDBOutcome; + typedef std::future DeleteHBaseHaDBOutcomeCallable; + typedef std::function&)> DeleteHBaseHaDBAsyncHandler; typedef Outcome DeleteHbaseHaSlbOutcome; typedef std::future DeleteHbaseHaSlbOutcomeCallable; typedef std::function&)> DeleteHbaseHaSlbAsyncHandler; @@ -206,6 +221,15 @@ namespace AlibabaCloud typedef Outcome DescribeIpWhitelistOutcome; typedef std::future DescribeIpWhitelistOutcomeCallable; typedef std::function&)> DescribeIpWhitelistAsyncHandler; + typedef Outcome DescribeMultiZoneAvailableRegionsOutcome; + typedef std::future DescribeMultiZoneAvailableRegionsOutcomeCallable; + typedef std::function&)> DescribeMultiZoneAvailableRegionsAsyncHandler; + typedef Outcome DescribeMultiZoneAvailableResourceOutcome; + typedef std::future DescribeMultiZoneAvailableResourceOutcomeCallable; + typedef std::function&)> DescribeMultiZoneAvailableResourceAsyncHandler; + typedef Outcome DescribeMultiZoneClusterOutcome; + typedef std::future DescribeMultiZoneClusterOutcomeCallable; + typedef std::function&)> DescribeMultiZoneClusterAsyncHandler; typedef Outcome DescribeRecoverableTimeRangeOutcome; typedef std::future DescribeRecoverableTimeRangeOutcomeCallable; typedef std::function&)> DescribeRecoverableTimeRangeAsyncHandler; @@ -236,6 +260,9 @@ namespace AlibabaCloud typedef Outcome EnableHBaseueModuleOutcome; typedef std::future EnableHBaseueModuleOutcomeCallable; typedef std::function&)> EnableHBaseueModuleAsyncHandler; + typedef Outcome EvaluateMultiZoneResourceOutcome; + typedef std::future EvaluateMultiZoneResourceOutcomeCallable; + typedef std::function&)> EvaluateMultiZoneResourceAsyncHandler; typedef Outcome ListTagResourcesOutcome; typedef std::future ListTagResourcesOutcomeCallable; typedef std::function&)> ListTagResourcesAsyncHandler; @@ -293,6 +320,9 @@ namespace AlibabaCloud typedef Outcome UnTagResourcesOutcome; typedef std::future UnTagResourcesOutcomeCallable; typedef std::function&)> UnTagResourcesAsyncHandler; + typedef Outcome UpgradeMultiZoneClusterOutcome; + typedef std::future UpgradeMultiZoneClusterOutcomeCallable; + typedef std::function&)> UpgradeMultiZoneClusterAsyncHandler; typedef Outcome XpackRelateDBOutcome; typedef std::future XpackRelateDBOutcomeCallable; typedef std::function&)> 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; XpackRelateDBOutcomeCallable xpackRelateDBCallable(const Model::XpackRelateDBRequest& request) const; diff --git a/hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h b/hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h new file mode 100644 index 000000000..453eafbcd --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHADBREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h b/hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h new file mode 100644 index 000000000..2766784ac --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h new file mode 100644 index 000000000..f56ab3a42 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h new file mode 100644 index 000000000..a4733eba7 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h @@ -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 +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableRegionsResult : public ServiceResult + { + public: + struct Region + { + struct AvailableCombine + { + std::string id; + std::vector zones; + }; + std::string regionId; + std::vector availableCombines; + std::string regionEndpoint; + std::string localName; + }; + + + DescribeMultiZoneAvailableRegionsResult(); + explicit DescribeMultiZoneAvailableRegionsResult(const std::string &payload); + ~DescribeMultiZoneAvailableRegionsResult(); + std::vector getRegions()const; + + protected: + void parse(const std::string &payload); + private: + std::vector regions_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLEREGIONSRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h new file mode 100644 index 000000000..6ea5cbdae --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h new file mode 100644 index 000000000..c1f3fd2e8 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceResult.h @@ -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 +#include +#include +#include +#include + +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 coreResources; + }; + std::string category; + std::vector supportedStorageTypes; + }; + std::string version; + std::vector supportedCategories; + }; + std::vector supportedEngineVersions; + std::string engine; + }; + std::vector masterResources; + std::string zoneCombination; + std::vector supportedEngines; + std::string regionId; + }; + + + DescribeMultiZoneAvailableResourceResult(); + explicit DescribeMultiZoneAvailableResourceResult(const std::string &payload); + ~DescribeMultiZoneAvailableResourceResult(); + std::vector getAvailableZones()const; + + protected: + void parse(const std::string &payload); + private: + std::vector availableZones_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h new file mode 100644 index 000000000..d49fcd958 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h new file mode 100644 index 000000000..75d4ef3ab --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h @@ -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 +#include +#include +#include +#include + +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 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 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 tags_; + std::string engine_; + std::string maintainStartTime_; + std::string arbiterZoneId_; + std::string majorVersion_; + std::string coreDiskCount_; + std::string parentId_; + std::string status_; + std::vector 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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h b/hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h new file mode 100644 index 000000000..2286a8fc8 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h b/hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h new file mode 100644 index 000000000..cb4b342fc --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h b/hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h new file mode 100644 index 000000000..c15b6f1be --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h b/hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h new file mode 100644 index 000000000..3ccf6a73e --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/hbase/src/HBaseClient.cc b/hbase/src/HBaseClient.cc index 0e826e2a6..56861dcc1 100644 --- a/hbase/src/HBaseClient.cc +++ b/hbase/src/HBaseClient.cc @@ -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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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(); diff --git a/hbase/src/model/DeleteHBaseHaDBRequest.cc b/hbase/src/model/DeleteHBaseHaDBRequest.cc new file mode 100644 index 000000000..3cd53bfff --- /dev/null +++ b/hbase/src/model/DeleteHBaseHaDBRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +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); +} + diff --git a/hbase/src/model/DeleteHBaseHaDBResult.cc b/hbase/src/model/DeleteHBaseHaDBResult.cc new file mode 100644 index 000000000..0cc36b245 --- /dev/null +++ b/hbase/src/model/DeleteHBaseHaDBResult.cc @@ -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 +#include + +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()); + +} + diff --git a/hbase/src/model/DescribeMultiZoneAvailableRegionsRequest.cc b/hbase/src/model/DescribeMultiZoneAvailableRegionsRequest.cc new file mode 100644 index 000000000..8e31453f4 --- /dev/null +++ b/hbase/src/model/DescribeMultiZoneAvailableRegionsRequest.cc @@ -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 + +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); +} + diff --git a/hbase/src/model/DescribeMultiZoneAvailableRegionsResult.cc b/hbase/src/model/DescribeMultiZoneAvailableRegionsResult.cc new file mode 100644 index 000000000..548c95b46 --- /dev/null +++ b/hbase/src/model/DescribeMultiZoneAvailableRegionsResult.cc @@ -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 +#include + +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::getRegions()const +{ + return regions_; +} + diff --git a/hbase/src/model/DescribeMultiZoneAvailableResourceRequest.cc b/hbase/src/model/DescribeMultiZoneAvailableResourceRequest.cc new file mode 100644 index 000000000..1d0cb94a5 --- /dev/null +++ b/hbase/src/model/DescribeMultiZoneAvailableResourceRequest.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::HBase::Model::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); +} + diff --git a/hbase/src/model/DescribeMultiZoneAvailableResourceResult.cc b/hbase/src/model/DescribeMultiZoneAvailableResourceResult.cc new file mode 100644 index 000000000..6fe9cf509 --- /dev/null +++ b/hbase/src/model/DescribeMultiZoneAvailableResourceResult.cc @@ -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 +#include + +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::getAvailableZones()const +{ + return availableZones_; +} + diff --git a/hbase/src/model/DescribeMultiZoneClusterRequest.cc b/hbase/src/model/DescribeMultiZoneClusterRequest.cc new file mode 100644 index 000000000..574e78475 --- /dev/null +++ b/hbase/src/model/DescribeMultiZoneClusterRequest.cc @@ -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 + +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); +} + diff --git a/hbase/src/model/DescribeMultiZoneClusterResult.cc b/hbase/src/model/DescribeMultiZoneClusterResult.cc new file mode 100644 index 000000000..afa5e9b4e --- /dev/null +++ b/hbase/src/model/DescribeMultiZoneClusterResult.cc @@ -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 +#include + +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::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::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_; +} + diff --git a/hbase/src/model/EvaluateMultiZoneResourceRequest.cc b/hbase/src/model/EvaluateMultiZoneResourceRequest.cc new file mode 100644 index 000000000..f2f336151 --- /dev/null +++ b/hbase/src/model/EvaluateMultiZoneResourceRequest.cc @@ -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 + +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); +} + diff --git a/hbase/src/model/EvaluateMultiZoneResourceResult.cc b/hbase/src/model/EvaluateMultiZoneResourceResult.cc new file mode 100644 index 000000000..33561ff58 --- /dev/null +++ b/hbase/src/model/EvaluateMultiZoneResourceResult.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +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_; +} + diff --git a/hbase/src/model/UpgradeMultiZoneClusterRequest.cc b/hbase/src/model/UpgradeMultiZoneClusterRequest.cc new file mode 100644 index 000000000..70c0604fe --- /dev/null +++ b/hbase/src/model/UpgradeMultiZoneClusterRequest.cc @@ -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 + +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); +} + diff --git a/hbase/src/model/UpgradeMultiZoneClusterResult.cc b/hbase/src/model/UpgradeMultiZoneClusterResult.cc new file mode 100644 index 000000000..b81037eff --- /dev/null +++ b/hbase/src/model/UpgradeMultiZoneClusterResult.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +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_; +} +