diff --git a/CHANGELOG b/CHANGELOG index 5659a4199..9cdceb4e6 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2019-11-20 Version 1.36.185 +- Generated 2019-01-01 for `HBase`. + 2019-11-20 Version 1.36.184 - Add API ReportVoipProblems. - Add API QueryVoipNumberBindINfos. diff --git a/VERSION b/VERSION index 77722c985..de1c42cc2 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.184 \ No newline at end of file +1.36.185 \ No newline at end of file diff --git a/hbase/CMakeLists.txt b/hbase/CMakeLists.txt new file mode 100644 index 000000000..8d1788706 --- /dev/null +++ b/hbase/CMakeLists.txt @@ -0,0 +1,166 @@ +# +# 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. +# + +set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include) + +set(hbase_public_header + include/alibabacloud/hbase/HBaseClient.h + include/alibabacloud/hbase/HBaseExport.h ) + +set(hbase_public_header_model + include/alibabacloud/hbase/model/AddUserHdfsInfoRequest.h + include/alibabacloud/hbase/model/AddUserHdfsInfoResult.h + include/alibabacloud/hbase/model/ConvertInstanceRequest.h + include/alibabacloud/hbase/model/ConvertInstanceResult.h + include/alibabacloud/hbase/model/CreateInstanceRequest.h + include/alibabacloud/hbase/model/CreateInstanceResult.h + include/alibabacloud/hbase/model/DeleteInstanceRequest.h + include/alibabacloud/hbase/model/DeleteInstanceResult.h + include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.h + include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.h + include/alibabacloud/hbase/model/DescribeEndpointsRequest.h + include/alibabacloud/hbase/model/DescribeEndpointsResult.h + include/alibabacloud/hbase/model/DescribeInstanceRequest.h + include/alibabacloud/hbase/model/DescribeInstanceResult.h + include/alibabacloud/hbase/model/DescribeInstancesRequest.h + include/alibabacloud/hbase/model/DescribeInstancesResult.h + include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h + include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h + include/alibabacloud/hbase/model/DescribeRegionsRequest.h + include/alibabacloud/hbase/model/DescribeRegionsResult.h + include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h + include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h + include/alibabacloud/hbase/model/ModifyInstanceNameRequest.h + include/alibabacloud/hbase/model/ModifyInstanceNameResult.h + include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h + include/alibabacloud/hbase/model/ModifyIpWhitelistResult.h + include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.h + include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h + include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h + include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.h + include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.h + include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h + include/alibabacloud/hbase/model/RenewInstanceRequest.h + include/alibabacloud/hbase/model/RenewInstanceResult.h + include/alibabacloud/hbase/model/ResizeDiskSizeRequest.h + include/alibabacloud/hbase/model/ResizeDiskSizeResult.h + include/alibabacloud/hbase/model/ResizeNodeCountRequest.h + include/alibabacloud/hbase/model/ResizeNodeCountResult.h + include/alibabacloud/hbase/model/RestartInstanceRequest.h + include/alibabacloud/hbase/model/RestartInstanceResult.h + include/alibabacloud/hbase/model/XpackRelateDBRequest.h + include/alibabacloud/hbase/model/XpackRelateDBResult.h ) + +set(hbase_src + src/HBaseClient.cc + src/model/AddUserHdfsInfoRequest.cc + src/model/AddUserHdfsInfoResult.cc + src/model/ConvertInstanceRequest.cc + src/model/ConvertInstanceResult.cc + src/model/CreateInstanceRequest.cc + src/model/CreateInstanceResult.cc + src/model/DeleteInstanceRequest.cc + src/model/DeleteInstanceResult.cc + src/model/DeleteUserHdfsInfoRequest.cc + src/model/DeleteUserHdfsInfoResult.cc + src/model/DescribeEndpointsRequest.cc + src/model/DescribeEndpointsResult.cc + src/model/DescribeInstanceRequest.cc + src/model/DescribeInstanceResult.cc + src/model/DescribeInstancesRequest.cc + src/model/DescribeInstancesResult.cc + src/model/DescribeIpWhitelistRequest.cc + src/model/DescribeIpWhitelistResult.cc + src/model/DescribeRegionsRequest.cc + src/model/DescribeRegionsResult.cc + src/model/DescribeSecurityGroupsRequest.cc + src/model/DescribeSecurityGroupsResult.cc + src/model/ModifyInstanceNameRequest.cc + src/model/ModifyInstanceNameResult.cc + src/model/ModifyIpWhitelistRequest.cc + src/model/ModifyIpWhitelistResult.cc + src/model/ModifySecurityGroupsRequest.cc + src/model/ModifySecurityGroupsResult.cc + src/model/ModifyUIAccountPasswordRequest.cc + src/model/ModifyUIAccountPasswordResult.cc + src/model/QueryXpackRelateDBRequest.cc + src/model/QueryXpackRelateDBResult.cc + src/model/RenewInstanceRequest.cc + src/model/RenewInstanceResult.cc + src/model/ResizeDiskSizeRequest.cc + src/model/ResizeDiskSizeResult.cc + src/model/ResizeNodeCountRequest.cc + src/model/ResizeNodeCountResult.cc + src/model/RestartInstanceRequest.cc + src/model/RestartInstanceResult.cc + src/model/XpackRelateDBRequest.cc + src/model/XpackRelateDBResult.cc ) + +add_library(hbase ${LIB_TYPE} + ${hbase_public_header} + ${hbase_public_header_model} + ${hbase_src}) + +set_target_properties(hbase + PROPERTIES + LINKER_LANGUAGE CXX + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin + OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}hbase + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(hbase + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_HBASE_LIBRARY) +endif() + +target_include_directories(hbase + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(hbase + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(hbase + jsoncpp) + target_include_directories(hbase + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(hbase + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(hbase + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(hbase + PRIVATE /usr/include/jsoncpp) + target_link_libraries(hbase + jsoncpp) +endif() + +install(FILES ${hbase_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/hbase) +install(FILES ${hbase_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/hbase/model) +install(TARGETS hbase + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/HBaseClient.h b/hbase/include/alibabacloud/hbase/HBaseClient.h new file mode 100644 index 000000000..1a596de81 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/HBaseClient.h @@ -0,0 +1,214 @@ +/* + * 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_HBASECLIENT_H_ +#define ALIBABACLOUD_HBASE_HBASECLIENT_H_ + +#include +#include +#include +#include +#include "HBaseExport.h" +#include "model/AddUserHdfsInfoRequest.h" +#include "model/AddUserHdfsInfoResult.h" +#include "model/ConvertInstanceRequest.h" +#include "model/ConvertInstanceResult.h" +#include "model/CreateInstanceRequest.h" +#include "model/CreateInstanceResult.h" +#include "model/DeleteInstanceRequest.h" +#include "model/DeleteInstanceResult.h" +#include "model/DeleteUserHdfsInfoRequest.h" +#include "model/DeleteUserHdfsInfoResult.h" +#include "model/DescribeEndpointsRequest.h" +#include "model/DescribeEndpointsResult.h" +#include "model/DescribeInstanceRequest.h" +#include "model/DescribeInstanceResult.h" +#include "model/DescribeInstancesRequest.h" +#include "model/DescribeInstancesResult.h" +#include "model/DescribeIpWhitelistRequest.h" +#include "model/DescribeIpWhitelistResult.h" +#include "model/DescribeRegionsRequest.h" +#include "model/DescribeRegionsResult.h" +#include "model/DescribeSecurityGroupsRequest.h" +#include "model/DescribeSecurityGroupsResult.h" +#include "model/ModifyInstanceNameRequest.h" +#include "model/ModifyInstanceNameResult.h" +#include "model/ModifyIpWhitelistRequest.h" +#include "model/ModifyIpWhitelistResult.h" +#include "model/ModifySecurityGroupsRequest.h" +#include "model/ModifySecurityGroupsResult.h" +#include "model/ModifyUIAccountPasswordRequest.h" +#include "model/ModifyUIAccountPasswordResult.h" +#include "model/QueryXpackRelateDBRequest.h" +#include "model/QueryXpackRelateDBResult.h" +#include "model/RenewInstanceRequest.h" +#include "model/RenewInstanceResult.h" +#include "model/ResizeDiskSizeRequest.h" +#include "model/ResizeDiskSizeResult.h" +#include "model/ResizeNodeCountRequest.h" +#include "model/ResizeNodeCountResult.h" +#include "model/RestartInstanceRequest.h" +#include "model/RestartInstanceResult.h" +#include "model/XpackRelateDBRequest.h" +#include "model/XpackRelateDBResult.h" + + +namespace AlibabaCloud +{ + namespace HBase + { + class ALIBABACLOUD_HBASE_EXPORT HBaseClient : public RpcServiceClient + { + public: + typedef Outcome AddUserHdfsInfoOutcome; + typedef std::future AddUserHdfsInfoOutcomeCallable; + typedef std::function&)> AddUserHdfsInfoAsyncHandler; + typedef Outcome ConvertInstanceOutcome; + typedef std::future ConvertInstanceOutcomeCallable; + typedef std::function&)> ConvertInstanceAsyncHandler; + typedef Outcome CreateInstanceOutcome; + typedef std::future CreateInstanceOutcomeCallable; + typedef std::function&)> CreateInstanceAsyncHandler; + typedef Outcome DeleteInstanceOutcome; + typedef std::future DeleteInstanceOutcomeCallable; + typedef std::function&)> DeleteInstanceAsyncHandler; + typedef Outcome DeleteUserHdfsInfoOutcome; + typedef std::future DeleteUserHdfsInfoOutcomeCallable; + typedef std::function&)> DeleteUserHdfsInfoAsyncHandler; + typedef Outcome DescribeEndpointsOutcome; + typedef std::future DescribeEndpointsOutcomeCallable; + typedef std::function&)> DescribeEndpointsAsyncHandler; + typedef Outcome DescribeInstanceOutcome; + typedef std::future DescribeInstanceOutcomeCallable; + typedef std::function&)> DescribeInstanceAsyncHandler; + typedef Outcome DescribeInstancesOutcome; + typedef std::future DescribeInstancesOutcomeCallable; + typedef std::function&)> DescribeInstancesAsyncHandler; + typedef Outcome DescribeIpWhitelistOutcome; + typedef std::future DescribeIpWhitelistOutcomeCallable; + typedef std::function&)> DescribeIpWhitelistAsyncHandler; + typedef Outcome DescribeRegionsOutcome; + typedef std::future DescribeRegionsOutcomeCallable; + typedef std::function&)> DescribeRegionsAsyncHandler; + typedef Outcome DescribeSecurityGroupsOutcome; + typedef std::future DescribeSecurityGroupsOutcomeCallable; + typedef std::function&)> DescribeSecurityGroupsAsyncHandler; + typedef Outcome ModifyInstanceNameOutcome; + typedef std::future ModifyInstanceNameOutcomeCallable; + typedef std::function&)> ModifyInstanceNameAsyncHandler; + typedef Outcome ModifyIpWhitelistOutcome; + typedef std::future ModifyIpWhitelistOutcomeCallable; + typedef std::function&)> ModifyIpWhitelistAsyncHandler; + typedef Outcome ModifySecurityGroupsOutcome; + typedef std::future ModifySecurityGroupsOutcomeCallable; + typedef std::function&)> ModifySecurityGroupsAsyncHandler; + typedef Outcome ModifyUIAccountPasswordOutcome; + typedef std::future ModifyUIAccountPasswordOutcomeCallable; + typedef std::function&)> ModifyUIAccountPasswordAsyncHandler; + typedef Outcome QueryXpackRelateDBOutcome; + typedef std::future QueryXpackRelateDBOutcomeCallable; + typedef std::function&)> QueryXpackRelateDBAsyncHandler; + typedef Outcome RenewInstanceOutcome; + typedef std::future RenewInstanceOutcomeCallable; + typedef std::function&)> RenewInstanceAsyncHandler; + typedef Outcome ResizeDiskSizeOutcome; + typedef std::future ResizeDiskSizeOutcomeCallable; + typedef std::function&)> ResizeDiskSizeAsyncHandler; + typedef Outcome ResizeNodeCountOutcome; + typedef std::future ResizeNodeCountOutcomeCallable; + typedef std::function&)> ResizeNodeCountAsyncHandler; + typedef Outcome RestartInstanceOutcome; + typedef std::future RestartInstanceOutcomeCallable; + typedef std::function&)> RestartInstanceAsyncHandler; + typedef Outcome XpackRelateDBOutcome; + typedef std::future XpackRelateDBOutcomeCallable; + typedef std::function&)> XpackRelateDBAsyncHandler; + + HBaseClient(const Credentials &credentials, const ClientConfiguration &configuration); + HBaseClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + HBaseClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~HBaseClient(); + AddUserHdfsInfoOutcome addUserHdfsInfo(const Model::AddUserHdfsInfoRequest &request)const; + void addUserHdfsInfoAsync(const Model::AddUserHdfsInfoRequest& request, const AddUserHdfsInfoAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddUserHdfsInfoOutcomeCallable addUserHdfsInfoCallable(const Model::AddUserHdfsInfoRequest& request) const; + ConvertInstanceOutcome convertInstance(const Model::ConvertInstanceRequest &request)const; + void convertInstanceAsync(const Model::ConvertInstanceRequest& request, const ConvertInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ConvertInstanceOutcomeCallable convertInstanceCallable(const Model::ConvertInstanceRequest& request) const; + CreateInstanceOutcome createInstance(const Model::CreateInstanceRequest &request)const; + void createInstanceAsync(const Model::CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateInstanceOutcomeCallable createInstanceCallable(const Model::CreateInstanceRequest& request) const; + DeleteInstanceOutcome deleteInstance(const Model::DeleteInstanceRequest &request)const; + void deleteInstanceAsync(const Model::DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteInstanceOutcomeCallable deleteInstanceCallable(const Model::DeleteInstanceRequest& request) const; + DeleteUserHdfsInfoOutcome deleteUserHdfsInfo(const Model::DeleteUserHdfsInfoRequest &request)const; + void deleteUserHdfsInfoAsync(const Model::DeleteUserHdfsInfoRequest& request, const DeleteUserHdfsInfoAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteUserHdfsInfoOutcomeCallable deleteUserHdfsInfoCallable(const Model::DeleteUserHdfsInfoRequest& request) const; + DescribeEndpointsOutcome describeEndpoints(const Model::DescribeEndpointsRequest &request)const; + void describeEndpointsAsync(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeEndpointsOutcomeCallable describeEndpointsCallable(const Model::DescribeEndpointsRequest& request) const; + DescribeInstanceOutcome describeInstance(const Model::DescribeInstanceRequest &request)const; + void describeInstanceAsync(const Model::DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeInstanceOutcomeCallable describeInstanceCallable(const Model::DescribeInstanceRequest& request) const; + DescribeInstancesOutcome describeInstances(const Model::DescribeInstancesRequest &request)const; + void describeInstancesAsync(const Model::DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeInstancesOutcomeCallable describeInstancesCallable(const Model::DescribeInstancesRequest& request) const; + 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; + DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const; + void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const; + DescribeSecurityGroupsOutcome describeSecurityGroups(const Model::DescribeSecurityGroupsRequest &request)const; + void describeSecurityGroupsAsync(const Model::DescribeSecurityGroupsRequest& request, const DescribeSecurityGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeSecurityGroupsOutcomeCallable describeSecurityGroupsCallable(const Model::DescribeSecurityGroupsRequest& request) const; + ModifyInstanceNameOutcome modifyInstanceName(const Model::ModifyInstanceNameRequest &request)const; + void modifyInstanceNameAsync(const Model::ModifyInstanceNameRequest& request, const ModifyInstanceNameAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyInstanceNameOutcomeCallable modifyInstanceNameCallable(const Model::ModifyInstanceNameRequest& request) const; + ModifyIpWhitelistOutcome modifyIpWhitelist(const Model::ModifyIpWhitelistRequest &request)const; + void modifyIpWhitelistAsync(const Model::ModifyIpWhitelistRequest& request, const ModifyIpWhitelistAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyIpWhitelistOutcomeCallable modifyIpWhitelistCallable(const Model::ModifyIpWhitelistRequest& request) const; + ModifySecurityGroupsOutcome modifySecurityGroups(const Model::ModifySecurityGroupsRequest &request)const; + void modifySecurityGroupsAsync(const Model::ModifySecurityGroupsRequest& request, const ModifySecurityGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifySecurityGroupsOutcomeCallable modifySecurityGroupsCallable(const Model::ModifySecurityGroupsRequest& request) const; + ModifyUIAccountPasswordOutcome modifyUIAccountPassword(const Model::ModifyUIAccountPasswordRequest &request)const; + void modifyUIAccountPasswordAsync(const Model::ModifyUIAccountPasswordRequest& request, const ModifyUIAccountPasswordAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyUIAccountPasswordOutcomeCallable modifyUIAccountPasswordCallable(const Model::ModifyUIAccountPasswordRequest& request) const; + QueryXpackRelateDBOutcome queryXpackRelateDB(const Model::QueryXpackRelateDBRequest &request)const; + void queryXpackRelateDBAsync(const Model::QueryXpackRelateDBRequest& request, const QueryXpackRelateDBAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryXpackRelateDBOutcomeCallable queryXpackRelateDBCallable(const Model::QueryXpackRelateDBRequest& request) const; + RenewInstanceOutcome renewInstance(const Model::RenewInstanceRequest &request)const; + void renewInstanceAsync(const Model::RenewInstanceRequest& request, const RenewInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RenewInstanceOutcomeCallable renewInstanceCallable(const Model::RenewInstanceRequest& request) const; + ResizeDiskSizeOutcome resizeDiskSize(const Model::ResizeDiskSizeRequest &request)const; + void resizeDiskSizeAsync(const Model::ResizeDiskSizeRequest& request, const ResizeDiskSizeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ResizeDiskSizeOutcomeCallable resizeDiskSizeCallable(const Model::ResizeDiskSizeRequest& request) const; + ResizeNodeCountOutcome resizeNodeCount(const Model::ResizeNodeCountRequest &request)const; + void resizeNodeCountAsync(const Model::ResizeNodeCountRequest& request, const ResizeNodeCountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ResizeNodeCountOutcomeCallable resizeNodeCountCallable(const Model::ResizeNodeCountRequest& request) const; + RestartInstanceOutcome restartInstance(const Model::RestartInstanceRequest &request)const; + void restartInstanceAsync(const Model::RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RestartInstanceOutcomeCallable restartInstanceCallable(const Model::RestartInstanceRequest& 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; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_HBASE_HBASECLIENT_H_ diff --git a/hbase/include/alibabacloud/hbase/HBaseExport.h b/hbase/include/alibabacloud/hbase/HBaseExport.h new file mode 100644 index 000000000..8df7a340f --- /dev/null +++ b/hbase/include/alibabacloud/hbase/HBaseExport.h @@ -0,0 +1,32 @@ +/* + * 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_HBASEEXPORT_H_ +#define ALIBABACLOUD_HBASE_HBASEEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_HBASE_LIBRARY) +# define ALIBABACLOUD_HBASE_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_HBASE_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_HBASE_EXPORT +#endif + +#endif // !ALIBABACLOUD_HBASE_HBASEEXPORT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoRequest.h b/hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoRequest.h new file mode 100644 index 000000000..8e4690f85 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoRequest.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_ADDUSERHDFSINFOREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFOREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT AddUserHdfsInfoRequest : public RpcServiceRequest + { + + public: + AddUserHdfsInfoRequest(); + ~AddUserHdfsInfoRequest(); + + std::string getExtInfo()const; + void setExtInfo(const std::string& extInfo); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string extInfo_; + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFOREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoResult.h b/hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoResult.h new file mode 100644 index 000000000..6f2d04608 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoResult.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_ADDUSERHDFSINFORESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFORESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT AddUserHdfsInfoResult : public ServiceResult + { + public: + + + AddUserHdfsInfoResult(); + explicit AddUserHdfsInfoResult(const std::string &payload); + ~AddUserHdfsInfoResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFORESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ConvertInstanceRequest.h b/hbase/include/alibabacloud/hbase/model/ConvertInstanceRequest.h new file mode 100644 index 000000000..47fc1a6b5 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ConvertInstanceRequest.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_CONVERTINSTANCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ConvertInstanceRequest : public RpcServiceRequest + { + + public: + ConvertInstanceRequest(); + ~ConvertInstanceRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getDuration()const; + void setDuration(int duration); + std::string getPricingCycle()const; + void setPricingCycle(const std::string& pricingCycle); + + private: + std::string clusterId_; + int duration_; + std::string pricingCycle_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ConvertInstanceResult.h b/hbase/include/alibabacloud/hbase/model/ConvertInstanceResult.h new file mode 100644 index 000000000..4d9196608 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ConvertInstanceResult.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_CONVERTINSTANCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ConvertInstanceResult : public ServiceResult + { + public: + + + ConvertInstanceResult(); + explicit ConvertInstanceResult(const std::string &payload); + ~ConvertInstanceResult(); + long getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + long orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/CreateInstanceRequest.h b/hbase/include/alibabacloud/hbase/model/CreateInstanceRequest.h new file mode 100644 index 000000000..5c12c45e2 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/CreateInstanceRequest.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_CREATEINSTANCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT CreateInstanceRequest : public RpcServiceRequest + { + + public: + CreateInstanceRequest(); + ~CreateInstanceRequest(); + + std::string getClusterName()const; + void setClusterName(const std::string& clusterName); + std::string getDbInstanceConnType()const; + void setDbInstanceConnType(const std::string& dbInstanceConnType); + std::string getEngineVersion()const; + void setEngineVersion(const std::string& engineVersion); + std::string getDepMode()const; + void setDepMode(const std::string& depMode); + std::string getBackupId()const; + void setBackupId(const std::string& backupId); + std::string getDbInstanceType()const; + void setDbInstanceType(const std::string& dbInstanceType); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getSecurityIPList()const; + void setSecurityIPList(const std::string& securityIPList); + std::string getAutoRenew()const; + void setAutoRenew(const std::string& autoRenew); + std::string getNetType()const; + void setNetType(const std::string& netType); + std::string getZoneId()const; + void setZoneId(const std::string& zoneId); + std::string getCoreDiskType()const; + void setCoreDiskType(const std::string& coreDiskType); + std::string getPricingCycle()const; + void setPricingCycle(const std::string& pricingCycle); + std::string getCoreInstanceQuantity()const; + void setCoreInstanceQuantity(const std::string& coreInstanceQuantity); + std::string getDuration()const; + void setDuration(const std::string& duration); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getEngine()const; + void setEngine(const std::string& engine); + std::string getRestoreTime()const; + void setRestoreTime(const std::string& restoreTime); + std::string getSrcDBInstanceId()const; + void setSrcDBInstanceId(const std::string& srcDBInstanceId); + std::string getMasterInstanceType()const; + void setMasterInstanceType(const std::string& masterInstanceType); + std::string getColdStorageSize()const; + void setColdStorageSize(const std::string& coldStorageSize); + std::string getCoreDiskQuantity()const; + void setCoreDiskQuantity(const std::string& coreDiskQuantity); + std::string getIsColdStorage()const; + void setIsColdStorage(const std::string& isColdStorage); + std::string getCoreInstanceType()const; + void setCoreInstanceType(const std::string& coreInstanceType); + std::string getCoreDiskSize()const; + void setCoreDiskSize(const std::string& coreDiskSize); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + std::string getDbType()const; + void setDbType(const std::string& dbType); + std::string getPayType()const; + void setPayType(const std::string& payType); + + private: + std::string clusterName_; + std::string dbInstanceConnType_; + std::string engineVersion_; + std::string depMode_; + std::string backupId_; + std::string dbInstanceType_; + std::string vSwitchId_; + std::string securityIPList_; + std::string autoRenew_; + std::string netType_; + std::string zoneId_; + std::string coreDiskType_; + std::string pricingCycle_; + std::string coreInstanceQuantity_; + std::string duration_; + std::string regionId_; + std::string engine_; + std::string restoreTime_; + std::string srcDBInstanceId_; + std::string masterInstanceType_; + std::string coldStorageSize_; + std::string coreDiskQuantity_; + std::string isColdStorage_; + std::string coreInstanceType_; + std::string coreDiskSize_; + std::string vpcId_; + std::string dbType_; + std::string payType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/CreateInstanceResult.h b/hbase/include/alibabacloud/hbase/model/CreateInstanceResult.h new file mode 100644 index 000000000..800f8e0bc --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/CreateInstanceResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT CreateInstanceResult : public ServiceResult + { + public: + + + CreateInstanceResult(); + explicit CreateInstanceResult(const std::string &payload); + ~CreateInstanceResult(); + std::string getClusterId()const; + std::string getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + std::string clusterId_; + std::string orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DeleteInstanceRequest.h b/hbase/include/alibabacloud/hbase/model/DeleteInstanceRequest.h new file mode 100644 index 000000000..613aa0ad6 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DeleteInstanceRequest.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_DELETEINSTANCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DeleteInstanceRequest : public RpcServiceRequest + { + + public: + DeleteInstanceRequest(); + ~DeleteInstanceRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DeleteInstanceResult.h b/hbase/include/alibabacloud/hbase/model/DeleteInstanceResult.h new file mode 100644 index 000000000..2e3885b10 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DeleteInstanceResult.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_DELETEINSTANCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DeleteInstanceResult : public ServiceResult + { + public: + + + DeleteInstanceResult(); + explicit DeleteInstanceResult(const std::string &payload); + ~DeleteInstanceResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.h b/hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.h new file mode 100644 index 000000000..bf804c614 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.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_DELETEUSERHDFSINFOREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFOREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DeleteUserHdfsInfoRequest : public RpcServiceRequest + { + + public: + DeleteUserHdfsInfoRequest(); + ~DeleteUserHdfsInfoRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getNameService()const; + void setNameService(const std::string& nameService); + + private: + std::string clusterId_; + std::string nameService_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFOREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.h b/hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.h new file mode 100644 index 000000000..49a988903 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.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_DELETEUSERHDFSINFORESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFORESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DeleteUserHdfsInfoResult : public ServiceResult + { + public: + + + DeleteUserHdfsInfoResult(); + explicit DeleteUserHdfsInfoResult(const std::string &payload); + ~DeleteUserHdfsInfoResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFORESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeEndpointsRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeEndpointsRequest.h new file mode 100644 index 000000000..9b5d673a9 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeEndpointsRequest.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_DESCRIBEENDPOINTSREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeEndpointsRequest : public RpcServiceRequest + { + + public: + DescribeEndpointsRequest(); + ~DescribeEndpointsRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeEndpointsResult.h b/hbase/include/alibabacloud/hbase/model/DescribeEndpointsResult.h new file mode 100644 index 000000000..200ea7213 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeEndpointsResult.h @@ -0,0 +1,66 @@ +/* + * 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_DESCRIBEENDPOINTSRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeEndpointsResult : public ServiceResult + { + public: + struct ConnAddrInfo + { + std::string connAddrPort; + std::string connAddr; + std::string connType; + std::string netType; + }; + + + DescribeEndpointsResult(); + explicit DescribeEndpointsResult(const std::string &payload); + ~DescribeEndpointsResult(); + std::string getVpcId()const; + std::vector getConnAddrs()const; + std::string getVSwitchId()const; + std::string getNetType()const; + std::string getEngine()const; + + protected: + void parse(const std::string &payload); + private: + std::string vpcId_; + std::vector connAddrs_; + std::string vSwitchId_; + std::string netType_; + std::string engine_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeInstanceRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeInstanceRequest.h new file mode 100644 index 000000000..6454628ea --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeInstanceRequest.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_DESCRIBEINSTANCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeInstanceRequest : public RpcServiceRequest + { + + public: + DescribeInstanceRequest(); + ~DescribeInstanceRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeInstanceResult.h b/hbase/include/alibabacloud/hbase/model/DescribeInstanceResult.h new file mode 100644 index 000000000..2d773d8eb --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeInstanceResult.h @@ -0,0 +1,108 @@ +/* + * 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_DESCRIBEINSTANCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeInstanceResult : public ServiceResult + { + public: + struct Tag + { + std::string value; + std::string key; + }; + + + DescribeInstanceResult(); + explicit DescribeInstanceResult(const std::string &payload); + ~DescribeInstanceResult(); + bool getIsHa()const; + std::string getCreatedTime()const; + std::string getMasterInstanceType()const; + std::string getNetworkType()const; + std::string getCoreInstanceType()const; + std::string getMasterDiskType()const; + std::vector getTags()const; + std::string getEngine()const; + std::string getStatus()const; + std::string getMajorVersion()const; + std::string getCoreDiskCount()const; + int getMasterDiskSize()const; + std::string getZoneId()const; + std::string getInstanceId()const; + int getCoreNodeCount()const; + std::string getColdStorageStatus()const; + std::string getMinorVersion()const; + std::string getPayType()const; + std::string getVswitchId()const; + std::string getInstanceName()const; + int getMasterNodeCount()const; + std::string getVpcId()const; + std::string getCoreDiskType()const; + std::string getRegionId()const; + std::string getExpireTime()const; + int getCoreDiskSize()const; + std::string getBackupStatus()const; + + protected: + void parse(const std::string &payload); + private: + bool isHa_; + std::string createdTime_; + std::string masterInstanceType_; + std::string networkType_; + std::string coreInstanceType_; + std::string masterDiskType_; + std::vector tags_; + std::string engine_; + std::string status_; + std::string majorVersion_; + std::string coreDiskCount_; + int masterDiskSize_; + std::string zoneId_; + std::string instanceId_; + int coreNodeCount_; + std::string coldStorageStatus_; + std::string minorVersion_; + std::string payType_; + std::string vswitchId_; + std::string instanceName_; + int masterNodeCount_; + std::string vpcId_; + std::string coreDiskType_; + std::string regionId_; + std::string expireTime_; + int coreDiskSize_; + std::string backupStatus_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeInstancesRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeInstancesRequest.h new file mode 100644 index 000000000..506def7f2 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeInstancesRequest.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_DESCRIBEINSTANCESREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeInstancesRequest : public RpcServiceRequest + { + + public: + DescribeInstancesRequest(); + ~DescribeInstancesRequest(); + + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPageSize()const; + void setPageSize(int pageSize); + + private: + int pageNumber_; + std::string regionId_; + int pageSize_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeInstancesResult.h b/hbase/include/alibabacloud/hbase/model/DescribeInstancesResult.h new file mode 100644 index 000000000..2f0362243 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeInstancesResult.h @@ -0,0 +1,84 @@ +/* + * 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_DESCRIBEINSTANCESRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeInstancesResult : public ServiceResult + { + public: + struct Instance + { + std::string status; + std::string majorVersion; + bool isHa; + std::string createdTime; + int masterDiskSize; + std::string zoneId; + std::string instanceId; + int coreNodeCount; + std::string coldStorageStatus; + std::string payType; + std::string masterInstanceType; + std::string vswitchId; + std::string instanceName; + int masterNodeCount; + std::string vpcId; + std::string coreDiskType; + std::string networkType; + std::string coreInstanceType; + std::string masterDiskType; + std::string regionId; + std::string expireTime; + std::string engine; + int coreDiskSize; + std::string backupStatus; + }; + + + DescribeInstancesResult(); + explicit DescribeInstancesResult(const std::string &payload); + ~DescribeInstancesResult(); + std::vector getInstances()const; + long getTotalCount()const; + int getPageSize()const; + int getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + std::vector instances_; + long totalCount_; + int pageSize_; + int pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h new file mode 100644 index 000000000..5157a7a04 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.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_DESCRIBEIPWHITELISTREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeIpWhitelistRequest : public RpcServiceRequest + { + + public: + DescribeIpWhitelistRequest(); + ~DescribeIpWhitelistRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h b/hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h new file mode 100644 index 000000000..ad5782f7c --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistResult.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_DESCRIBEIPWHITELISTRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeIpWhitelistResult : public ServiceResult + { + public: + + + DescribeIpWhitelistResult(); + explicit DescribeIpWhitelistResult(const std::string &payload); + ~DescribeIpWhitelistResult(); + std::vector getIpList()const; + + protected: + void parse(const std::string &payload); + private: + std::vector ipList_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeRegionsRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeRegionsRequest.h new file mode 100644 index 000000000..344fe89cc --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeRegionsRequest.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_DESCRIBEREGIONSREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeRegionsRequest : public RpcServiceRequest + { + + public: + DescribeRegionsRequest(); + ~DescribeRegionsRequest(); + + std::string getAcceptLanguage()const; + void setAcceptLanguage(const std::string& acceptLanguage); + + private: + std::string acceptLanguage_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeRegionsResult.h b/hbase/include/alibabacloud/hbase/model/DescribeRegionsResult.h new file mode 100644 index 000000000..cd6855751 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeRegionsResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeRegionsResult : public ServiceResult + { + public: + struct Region + { + struct Zone + { + std::string id; + }; + std::string regionId; + std::string regionEndpoint; + std::vector zones; + std::string localName; + }; + + + DescribeRegionsResult(); + explicit DescribeRegionsResult(const std::string &payload); + ~DescribeRegionsResult(); + std::vector getRegions()const; + + protected: + void parse(const std::string &payload); + private: + std::vector regions_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h b/hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h new file mode 100644 index 000000000..1d5f7664e --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.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_DESCRIBESECURITYGROUPSREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeSecurityGroupsRequest : public RpcServiceRequest + { + + public: + DescribeSecurityGroupsRequest(); + ~DescribeSecurityGroupsRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h b/hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h new file mode 100644 index 000000000..56df31f38 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.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_DESCRIBESECURITYGROUPSRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT DescribeSecurityGroupsResult : public ServiceResult + { + public: + + + DescribeSecurityGroupsResult(); + explicit DescribeSecurityGroupsResult(const std::string &payload); + ~DescribeSecurityGroupsResult(); + std::vector getSecurityGroupIds()const; + + protected: + void parse(const std::string &payload); + private: + std::vector securityGroupIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyInstanceNameRequest.h b/hbase/include/alibabacloud/hbase/model/ModifyInstanceNameRequest.h new file mode 100644 index 000000000..f125c55ff --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyInstanceNameRequest.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_MODIFYINSTANCENAMEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyInstanceNameRequest : public RpcServiceRequest + { + + public: + ModifyInstanceNameRequest(); + ~ModifyInstanceNameRequest(); + + std::string getClientToken()const; + void setClientToken(const std::string& clientToken); + std::string getClusterName()const; + void setClusterName(const std::string& clusterName); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getZoneId()const; + void setZoneId(const std::string& zoneId); + + private: + std::string clientToken_; + std::string clusterName_; + std::string clusterId_; + std::string accessKeyId_; + std::string regionId_; + std::string zoneId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyInstanceNameResult.h b/hbase/include/alibabacloud/hbase/model/ModifyInstanceNameResult.h new file mode 100644 index 000000000..36478ec61 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyInstanceNameResult.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_MODIFYINSTANCENAMERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyInstanceNameResult : public ServiceResult + { + public: + + + ModifyInstanceNameResult(); + explicit ModifyInstanceNameResult(const std::string &payload); + ~ModifyInstanceNameResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h b/hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h new file mode 100644 index 000000000..3f19a1aef --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h @@ -0,0 +1,57 @@ +/* + * 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_MODIFYIPWHITELISTREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyIpWhitelistRequest : public RpcServiceRequest + { + + public: + ModifyIpWhitelistRequest(); + ~ModifyIpWhitelistRequest(); + + std::string getIpList()const; + void setIpList(const std::string& ipList); + std::string getIpVersion()const; + void setIpVersion(const std::string& ipVersion); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getGroupName()const; + void setGroupName(const std::string& groupName); + + private: + std::string ipList_; + std::string ipVersion_; + std::string clusterId_; + std::string groupName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistResult.h b/hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistResult.h new file mode 100644 index 000000000..6c78986f6 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistResult.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_MODIFYIPWHITELISTRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyIpWhitelistResult : public ServiceResult + { + public: + + + ModifyIpWhitelistResult(); + explicit ModifyIpWhitelistResult(const std::string &payload); + ~ModifyIpWhitelistResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.h b/hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.h new file mode 100644 index 000000000..46547ed59 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.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_MODIFYSECURITYGROUPSREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifySecurityGroupsRequest : public RpcServiceRequest + { + + public: + ModifySecurityGroupsRequest(); + ~ModifySecurityGroupsRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getSecurityGroupIds()const; + void setSecurityGroupIds(const std::string& securityGroupIds); + + private: + std::string clusterId_; + std::string securityGroupIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h b/hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h new file mode 100644 index 000000000..845f22795 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsResult.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_MODIFYSECURITYGROUPSRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifySecurityGroupsResult : public ServiceResult + { + public: + + + ModifySecurityGroupsResult(); + explicit ModifySecurityGroupsResult(const std::string &payload); + ~ModifySecurityGroupsResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h b/hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h new file mode 100644 index 000000000..c3565c28d --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.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_MODIFYUIACCOUNTPASSWORDREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyUIAccountPasswordRequest : public RpcServiceRequest + { + + public: + ModifyUIAccountPasswordRequest(); + ~ModifyUIAccountPasswordRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getAccountPassword()const; + void setAccountPassword(const std::string& accountPassword); + std::string getAccountName()const; + void setAccountName(const std::string& accountName); + + private: + std::string clusterId_; + std::string accountPassword_; + std::string accountName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.h b/hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.h new file mode 100644 index 000000000..87fd677c5 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.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_MODIFYUIACCOUNTPASSWORDRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ModifyUIAccountPasswordResult : public ServiceResult + { + public: + + + ModifyUIAccountPasswordResult(); + explicit ModifyUIAccountPasswordResult(const std::string &payload); + ~ModifyUIAccountPasswordResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.h b/hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.h new file mode 100644 index 000000000..7e426ba92 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.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_QUERYXPACKRELATEDBREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT QueryXpackRelateDBRequest : public RpcServiceRequest + { + + public: + QueryXpackRelateDBRequest(); + ~QueryXpackRelateDBRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getRelateDbType()const; + void setRelateDbType(const std::string& relateDbType); + + private: + std::string clusterId_; + std::string relateDbType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h b/hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h new file mode 100644 index 000000000..6721d6438 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h @@ -0,0 +1,61 @@ +/* + * 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_QUERYXPACKRELATEDBRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT QueryXpackRelateDBResult : public ServiceResult + { + public: + struct Cluster + { + std::string status; + std::string dBVersion; + bool isRelated; + std::string clusterId; + std::string clusterName; + std::string dBType; + std::string lockMode; + }; + + + QueryXpackRelateDBResult(); + explicit QueryXpackRelateDBResult(const std::string &payload); + ~QueryXpackRelateDBResult(); + std::vector getClusterList()const; + + protected: + void parse(const std::string &payload); + private: + std::vector clusterList_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/RenewInstanceRequest.h b/hbase/include/alibabacloud/hbase/model/RenewInstanceRequest.h new file mode 100644 index 000000000..d45bf7536 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/RenewInstanceRequest.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_RENEWINSTANCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT RenewInstanceRequest : public RpcServiceRequest + { + + public: + RenewInstanceRequest(); + ~RenewInstanceRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getDuration()const; + void setDuration(int duration); + std::string getPricingCycle()const; + void setPricingCycle(const std::string& pricingCycle); + + private: + std::string clusterId_; + int duration_; + std::string pricingCycle_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/RenewInstanceResult.h b/hbase/include/alibabacloud/hbase/model/RenewInstanceResult.h new file mode 100644 index 000000000..d7558a510 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/RenewInstanceResult.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_RENEWINSTANCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT RenewInstanceResult : public ServiceResult + { + public: + + + RenewInstanceResult(); + explicit RenewInstanceResult(const std::string &payload); + ~RenewInstanceResult(); + long getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + long orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeDiskSizeRequest.h b/hbase/include/alibabacloud/hbase/model/ResizeDiskSizeRequest.h new file mode 100644 index 000000000..6bd307c2d --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeDiskSizeRequest.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_RESIZEDISKSIZEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeDiskSizeRequest : public RpcServiceRequest + { + + public: + ResizeDiskSizeRequest(); + ~ResizeDiskSizeRequest(); + + int getNodeDiskSize()const; + void setNodeDiskSize(int nodeDiskSize); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + int nodeDiskSize_; + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeDiskSizeResult.h b/hbase/include/alibabacloud/hbase/model/ResizeDiskSizeResult.h new file mode 100644 index 000000000..6460921ef --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeDiskSizeResult.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_RESIZEDISKSIZERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeDiskSizeResult : public ServiceResult + { + public: + + + ResizeDiskSizeResult(); + explicit ResizeDiskSizeResult(const std::string &payload); + ~ResizeDiskSizeResult(); + std::string getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + std::string orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h b/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.h new file mode 100644 index 000000000..9dacdea1a --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.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_RESIZENODECOUNTREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeNodeCountRequest : public RpcServiceRequest + { + + public: + ResizeNodeCountRequest(); + ~ResizeNodeCountRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + int getNodeCount()const; + void setNodeCount(int nodeCount); + + private: + std::string clusterId_; + int nodeCount_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/ResizeNodeCountResult.h b/hbase/include/alibabacloud/hbase/model/ResizeNodeCountResult.h new file mode 100644 index 000000000..66e352104 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/ResizeNodeCountResult.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_RESIZENODECOUNTRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT ResizeNodeCountResult : public ServiceResult + { + public: + + + ResizeNodeCountResult(); + explicit ResizeNodeCountResult(const std::string &payload); + ~ResizeNodeCountResult(); + std::string getOrderId()const; + + protected: + void parse(const std::string &payload); + private: + std::string orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTRESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/RestartInstanceRequest.h b/hbase/include/alibabacloud/hbase/model/RestartInstanceRequest.h new file mode 100644 index 000000000..ca08e7917 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/RestartInstanceRequest.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_RESTARTINSTANCEREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT RestartInstanceRequest : public RpcServiceRequest + { + + public: + RestartInstanceRequest(); + ~RestartInstanceRequest(); + + std::string getComponents()const; + void setComponents(const std::string& components); + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + + private: + std::string components_; + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/RestartInstanceResult.h b/hbase/include/alibabacloud/hbase/model/RestartInstanceResult.h new file mode 100644 index 000000000..b2e0507d7 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/RestartInstanceResult.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_RESTARTINSTANCERESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT RestartInstanceResult : public ServiceResult + { + public: + + + RestartInstanceResult(); + explicit RestartInstanceResult(const std::string &payload); + ~RestartInstanceResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCERESULT_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/XpackRelateDBRequest.h b/hbase/include/alibabacloud/hbase/model/XpackRelateDBRequest.h new file mode 100644 index 000000000..bb2a16522 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/XpackRelateDBRequest.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_XPACKRELATEDBREQUEST_H_ +#define ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT XpackRelateDBRequest : public RpcServiceRequest + { + + public: + XpackRelateDBRequest(); + ~XpackRelateDBRequest(); + + std::string getClusterId()const; + void setClusterId(const std::string& clusterId); + std::string getRelateDbType()const; + void setRelateDbType(const std::string& relateDbType); + std::string getDbClusterIds()const; + void setDbClusterIds(const std::string& dbClusterIds); + + private: + std::string clusterId_; + std::string relateDbType_; + std::string dbClusterIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBREQUEST_H_ \ No newline at end of file diff --git a/hbase/include/alibabacloud/hbase/model/XpackRelateDBResult.h b/hbase/include/alibabacloud/hbase/model/XpackRelateDBResult.h new file mode 100644 index 000000000..e1cecdb30 --- /dev/null +++ b/hbase/include/alibabacloud/hbase/model/XpackRelateDBResult.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_XPACKRELATEDBRESULT_H_ +#define ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace HBase + { + namespace Model + { + class ALIBABACLOUD_HBASE_EXPORT XpackRelateDBResult : public ServiceResult + { + public: + + + XpackRelateDBResult(); + explicit XpackRelateDBResult(const std::string &payload); + ~XpackRelateDBResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBRESULT_H_ \ No newline at end of file diff --git a/hbase/src/HBaseClient.cc b/hbase/src/HBaseClient.cc new file mode 100644 index 000000000..9943d7400 --- /dev/null +++ b/hbase/src/HBaseClient.cc @@ -0,0 +1,809 @@ +/* + * 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; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +namespace +{ + const std::string SERVICE_NAME = "HBase"; +} + +HBaseClient::HBaseClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "hbase"); +} + +HBaseClient::HBaseClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "hbase"); +} + +HBaseClient::HBaseClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "hbase"); +} + +HBaseClient::~HBaseClient() +{} + +HBaseClient::AddUserHdfsInfoOutcome HBaseClient::addUserHdfsInfo(const AddUserHdfsInfoRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AddUserHdfsInfoOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddUserHdfsInfoOutcome(AddUserHdfsInfoResult(outcome.result())); + else + return AddUserHdfsInfoOutcome(outcome.error()); +} + +void HBaseClient::addUserHdfsInfoAsync(const AddUserHdfsInfoRequest& request, const AddUserHdfsInfoAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addUserHdfsInfo(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::AddUserHdfsInfoOutcomeCallable HBaseClient::addUserHdfsInfoCallable(const AddUserHdfsInfoRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addUserHdfsInfo(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ConvertInstanceOutcome HBaseClient::convertInstance(const ConvertInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ConvertInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ConvertInstanceOutcome(ConvertInstanceResult(outcome.result())); + else + return ConvertInstanceOutcome(outcome.error()); +} + +void HBaseClient::convertInstanceAsync(const ConvertInstanceRequest& request, const ConvertInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, convertInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ConvertInstanceOutcomeCallable HBaseClient::convertInstanceCallable(const ConvertInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->convertInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::CreateInstanceOutcome HBaseClient::createInstance(const CreateInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateInstanceOutcome(CreateInstanceResult(outcome.result())); + else + return CreateInstanceOutcome(outcome.error()); +} + +void HBaseClient::createInstanceAsync(const CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::CreateInstanceOutcomeCallable HBaseClient::createInstanceCallable(const CreateInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DeleteInstanceOutcome HBaseClient::deleteInstance(const DeleteInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteInstanceOutcome(DeleteInstanceResult(outcome.result())); + else + return DeleteInstanceOutcome(outcome.error()); +} + +void HBaseClient::deleteInstanceAsync(const DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DeleteInstanceOutcomeCallable HBaseClient::deleteInstanceCallable(const DeleteInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DeleteUserHdfsInfoOutcome HBaseClient::deleteUserHdfsInfo(const DeleteUserHdfsInfoRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteUserHdfsInfoOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteUserHdfsInfoOutcome(DeleteUserHdfsInfoResult(outcome.result())); + else + return DeleteUserHdfsInfoOutcome(outcome.error()); +} + +void HBaseClient::deleteUserHdfsInfoAsync(const DeleteUserHdfsInfoRequest& request, const DeleteUserHdfsInfoAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteUserHdfsInfo(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DeleteUserHdfsInfoOutcomeCallable HBaseClient::deleteUserHdfsInfoCallable(const DeleteUserHdfsInfoRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteUserHdfsInfo(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DescribeEndpointsOutcome HBaseClient::describeEndpoints(const DescribeEndpointsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeEndpointsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeEndpointsOutcome(DescribeEndpointsResult(outcome.result())); + else + return DescribeEndpointsOutcome(outcome.error()); +} + +void HBaseClient::describeEndpointsAsync(const DescribeEndpointsRequest& request, const DescribeEndpointsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeEndpoints(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DescribeEndpointsOutcomeCallable HBaseClient::describeEndpointsCallable(const DescribeEndpointsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeEndpoints(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DescribeInstanceOutcome HBaseClient::describeInstance(const DescribeInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeInstanceOutcome(DescribeInstanceResult(outcome.result())); + else + return DescribeInstanceOutcome(outcome.error()); +} + +void HBaseClient::describeInstanceAsync(const DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DescribeInstanceOutcomeCallable HBaseClient::describeInstanceCallable(const DescribeInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DescribeInstancesOutcome HBaseClient::describeInstances(const DescribeInstancesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeInstancesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeInstancesOutcome(DescribeInstancesResult(outcome.result())); + else + return DescribeInstancesOutcome(outcome.error()); +} + +void HBaseClient::describeInstancesAsync(const DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeInstances(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DescribeInstancesOutcomeCallable HBaseClient::describeInstancesCallable(const DescribeInstancesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeInstances(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DescribeIpWhitelistOutcome HBaseClient::describeIpWhitelist(const DescribeIpWhitelistRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeIpWhitelistOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeIpWhitelistOutcome(DescribeIpWhitelistResult(outcome.result())); + else + return DescribeIpWhitelistOutcome(outcome.error()); +} + +void HBaseClient::describeIpWhitelistAsync(const DescribeIpWhitelistRequest& request, const DescribeIpWhitelistAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeIpWhitelist(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DescribeIpWhitelistOutcomeCallable HBaseClient::describeIpWhitelistCallable(const DescribeIpWhitelistRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeIpWhitelist(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DescribeRegionsOutcome HBaseClient::describeRegions(const DescribeRegionsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeRegionsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result())); + else + return DescribeRegionsOutcome(outcome.error()); +} + +void HBaseClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeRegions(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DescribeRegionsOutcomeCallable HBaseClient::describeRegionsCallable(const DescribeRegionsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeRegions(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::DescribeSecurityGroupsOutcome HBaseClient::describeSecurityGroups(const DescribeSecurityGroupsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeSecurityGroupsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeSecurityGroupsOutcome(DescribeSecurityGroupsResult(outcome.result())); + else + return DescribeSecurityGroupsOutcome(outcome.error()); +} + +void HBaseClient::describeSecurityGroupsAsync(const DescribeSecurityGroupsRequest& request, const DescribeSecurityGroupsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeSecurityGroups(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::DescribeSecurityGroupsOutcomeCallable HBaseClient::describeSecurityGroupsCallable(const DescribeSecurityGroupsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeSecurityGroups(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ModifyInstanceNameOutcome HBaseClient::modifyInstanceName(const ModifyInstanceNameRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyInstanceNameOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyInstanceNameOutcome(ModifyInstanceNameResult(outcome.result())); + else + return ModifyInstanceNameOutcome(outcome.error()); +} + +void HBaseClient::modifyInstanceNameAsync(const ModifyInstanceNameRequest& request, const ModifyInstanceNameAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyInstanceName(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ModifyInstanceNameOutcomeCallable HBaseClient::modifyInstanceNameCallable(const ModifyInstanceNameRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyInstanceName(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ModifyIpWhitelistOutcome HBaseClient::modifyIpWhitelist(const ModifyIpWhitelistRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyIpWhitelistOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyIpWhitelistOutcome(ModifyIpWhitelistResult(outcome.result())); + else + return ModifyIpWhitelistOutcome(outcome.error()); +} + +void HBaseClient::modifyIpWhitelistAsync(const ModifyIpWhitelistRequest& request, const ModifyIpWhitelistAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyIpWhitelist(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ModifyIpWhitelistOutcomeCallable HBaseClient::modifyIpWhitelistCallable(const ModifyIpWhitelistRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyIpWhitelist(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ModifySecurityGroupsOutcome HBaseClient::modifySecurityGroups(const ModifySecurityGroupsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifySecurityGroupsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifySecurityGroupsOutcome(ModifySecurityGroupsResult(outcome.result())); + else + return ModifySecurityGroupsOutcome(outcome.error()); +} + +void HBaseClient::modifySecurityGroupsAsync(const ModifySecurityGroupsRequest& request, const ModifySecurityGroupsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifySecurityGroups(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ModifySecurityGroupsOutcomeCallable HBaseClient::modifySecurityGroupsCallable(const ModifySecurityGroupsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifySecurityGroups(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ModifyUIAccountPasswordOutcome HBaseClient::modifyUIAccountPassword(const ModifyUIAccountPasswordRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyUIAccountPasswordOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyUIAccountPasswordOutcome(ModifyUIAccountPasswordResult(outcome.result())); + else + return ModifyUIAccountPasswordOutcome(outcome.error()); +} + +void HBaseClient::modifyUIAccountPasswordAsync(const ModifyUIAccountPasswordRequest& request, const ModifyUIAccountPasswordAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyUIAccountPassword(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ModifyUIAccountPasswordOutcomeCallable HBaseClient::modifyUIAccountPasswordCallable(const ModifyUIAccountPasswordRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyUIAccountPassword(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::QueryXpackRelateDBOutcome HBaseClient::queryXpackRelateDB(const QueryXpackRelateDBRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryXpackRelateDBOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryXpackRelateDBOutcome(QueryXpackRelateDBResult(outcome.result())); + else + return QueryXpackRelateDBOutcome(outcome.error()); +} + +void HBaseClient::queryXpackRelateDBAsync(const QueryXpackRelateDBRequest& request, const QueryXpackRelateDBAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryXpackRelateDB(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::QueryXpackRelateDBOutcomeCallable HBaseClient::queryXpackRelateDBCallable(const QueryXpackRelateDBRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryXpackRelateDB(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::RenewInstanceOutcome HBaseClient::renewInstance(const RenewInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RenewInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RenewInstanceOutcome(RenewInstanceResult(outcome.result())); + else + return RenewInstanceOutcome(outcome.error()); +} + +void HBaseClient::renewInstanceAsync(const RenewInstanceRequest& request, const RenewInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, renewInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::RenewInstanceOutcomeCallable HBaseClient::renewInstanceCallable(const RenewInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->renewInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ResizeDiskSizeOutcome HBaseClient::resizeDiskSize(const ResizeDiskSizeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ResizeDiskSizeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ResizeDiskSizeOutcome(ResizeDiskSizeResult(outcome.result())); + else + return ResizeDiskSizeOutcome(outcome.error()); +} + +void HBaseClient::resizeDiskSizeAsync(const ResizeDiskSizeRequest& request, const ResizeDiskSizeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, resizeDiskSize(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ResizeDiskSizeOutcomeCallable HBaseClient::resizeDiskSizeCallable(const ResizeDiskSizeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->resizeDiskSize(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::ResizeNodeCountOutcome HBaseClient::resizeNodeCount(const ResizeNodeCountRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ResizeNodeCountOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ResizeNodeCountOutcome(ResizeNodeCountResult(outcome.result())); + else + return ResizeNodeCountOutcome(outcome.error()); +} + +void HBaseClient::resizeNodeCountAsync(const ResizeNodeCountRequest& request, const ResizeNodeCountAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, resizeNodeCount(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::ResizeNodeCountOutcomeCallable HBaseClient::resizeNodeCountCallable(const ResizeNodeCountRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->resizeNodeCount(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::RestartInstanceOutcome HBaseClient::restartInstance(const RestartInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RestartInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RestartInstanceOutcome(RestartInstanceResult(outcome.result())); + else + return RestartInstanceOutcome(outcome.error()); +} + +void HBaseClient::restartInstanceAsync(const RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, restartInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::RestartInstanceOutcomeCallable HBaseClient::restartInstanceCallable(const RestartInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->restartInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +HBaseClient::XpackRelateDBOutcome HBaseClient::xpackRelateDB(const XpackRelateDBRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return XpackRelateDBOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return XpackRelateDBOutcome(XpackRelateDBResult(outcome.result())); + else + return XpackRelateDBOutcome(outcome.error()); +} + +void HBaseClient::xpackRelateDBAsync(const XpackRelateDBRequest& request, const XpackRelateDBAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, xpackRelateDB(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +HBaseClient::XpackRelateDBOutcomeCallable HBaseClient::xpackRelateDBCallable(const XpackRelateDBRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->xpackRelateDB(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/hbase/src/model/AddUserHdfsInfoRequest.cc b/hbase/src/model/AddUserHdfsInfoRequest.cc new file mode 100644 index 000000000..dbf0f0475 --- /dev/null +++ b/hbase/src/model/AddUserHdfsInfoRequest.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::AddUserHdfsInfoRequest; + +AddUserHdfsInfoRequest::AddUserHdfsInfoRequest() : + RpcServiceRequest("hbase", "2019-01-01", "AddUserHdfsInfo") +{ + setMethod(HttpRequest::Method::Post); +} + +AddUserHdfsInfoRequest::~AddUserHdfsInfoRequest() +{} + +std::string AddUserHdfsInfoRequest::getExtInfo()const +{ + return extInfo_; +} + +void AddUserHdfsInfoRequest::setExtInfo(const std::string& extInfo) +{ + extInfo_ = extInfo; + setCoreParameter("ExtInfo", extInfo); +} + +std::string AddUserHdfsInfoRequest::getClusterId()const +{ + return clusterId_; +} + +void AddUserHdfsInfoRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/AddUserHdfsInfoResult.cc b/hbase/src/model/AddUserHdfsInfoResult.cc new file mode 100644 index 000000000..ccf4dfd34 --- /dev/null +++ b/hbase/src/model/AddUserHdfsInfoResult.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; + +AddUserHdfsInfoResult::AddUserHdfsInfoResult() : + ServiceResult() +{} + +AddUserHdfsInfoResult::AddUserHdfsInfoResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddUserHdfsInfoResult::~AddUserHdfsInfoResult() +{} + +void AddUserHdfsInfoResult::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/ConvertInstanceRequest.cc b/hbase/src/model/ConvertInstanceRequest.cc new file mode 100644 index 000000000..baaf2ad02 --- /dev/null +++ b/hbase/src/model/ConvertInstanceRequest.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::ConvertInstanceRequest; + +ConvertInstanceRequest::ConvertInstanceRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ConvertInstance") +{ + setMethod(HttpRequest::Method::Post); +} + +ConvertInstanceRequest::~ConvertInstanceRequest() +{} + +std::string ConvertInstanceRequest::getClusterId()const +{ + return clusterId_; +} + +void ConvertInstanceRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int ConvertInstanceRequest::getDuration()const +{ + return duration_; +} + +void ConvertInstanceRequest::setDuration(int duration) +{ + duration_ = duration; + setCoreParameter("Duration", std::to_string(duration)); +} + +std::string ConvertInstanceRequest::getPricingCycle()const +{ + return pricingCycle_; +} + +void ConvertInstanceRequest::setPricingCycle(const std::string& pricingCycle) +{ + pricingCycle_ = pricingCycle; + setCoreParameter("PricingCycle", pricingCycle); +} + diff --git a/hbase/src/model/ConvertInstanceResult.cc b/hbase/src/model/ConvertInstanceResult.cc new file mode 100644 index 000000000..d2f1a8f03 --- /dev/null +++ b/hbase/src/model/ConvertInstanceResult.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; + +ConvertInstanceResult::ConvertInstanceResult() : + ServiceResult() +{} + +ConvertInstanceResult::ConvertInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ConvertInstanceResult::~ConvertInstanceResult() +{} + +void ConvertInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = std::stol(value["OrderId"].asString()); + +} + +long ConvertInstanceResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/CreateInstanceRequest.cc b/hbase/src/model/CreateInstanceRequest.cc new file mode 100644 index 000000000..d29a9adcf --- /dev/null +++ b/hbase/src/model/CreateInstanceRequest.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::CreateInstanceRequest; + +CreateInstanceRequest::CreateInstanceRequest() : + RpcServiceRequest("hbase", "2019-01-01", "CreateInstance") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateInstanceRequest::~CreateInstanceRequest() +{} + +std::string CreateInstanceRequest::getClusterName()const +{ + return clusterName_; +} + +void CreateInstanceRequest::setClusterName(const std::string& clusterName) +{ + clusterName_ = clusterName; + setCoreParameter("ClusterName", clusterName); +} + +std::string CreateInstanceRequest::getDbInstanceConnType()const +{ + return dbInstanceConnType_; +} + +void CreateInstanceRequest::setDbInstanceConnType(const std::string& dbInstanceConnType) +{ + dbInstanceConnType_ = dbInstanceConnType; + setCoreParameter("DbInstanceConnType", dbInstanceConnType); +} + +std::string CreateInstanceRequest::getEngineVersion()const +{ + return engineVersion_; +} + +void CreateInstanceRequest::setEngineVersion(const std::string& engineVersion) +{ + engineVersion_ = engineVersion; + setCoreParameter("EngineVersion", engineVersion); +} + +std::string CreateInstanceRequest::getDepMode()const +{ + return depMode_; +} + +void CreateInstanceRequest::setDepMode(const std::string& depMode) +{ + depMode_ = depMode; + setCoreParameter("DepMode", depMode); +} + +std::string CreateInstanceRequest::getBackupId()const +{ + return backupId_; +} + +void CreateInstanceRequest::setBackupId(const std::string& backupId) +{ + backupId_ = backupId; + setCoreParameter("BackupId", backupId); +} + +std::string CreateInstanceRequest::getDbInstanceType()const +{ + return dbInstanceType_; +} + +void CreateInstanceRequest::setDbInstanceType(const std::string& dbInstanceType) +{ + dbInstanceType_ = dbInstanceType; + setCoreParameter("DbInstanceType", dbInstanceType); +} + +std::string CreateInstanceRequest::getVSwitchId()const +{ + return vSwitchId_; +} + +void CreateInstanceRequest::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; + setCoreParameter("VSwitchId", vSwitchId); +} + +std::string CreateInstanceRequest::getSecurityIPList()const +{ + return securityIPList_; +} + +void CreateInstanceRequest::setSecurityIPList(const std::string& securityIPList) +{ + securityIPList_ = securityIPList; + setCoreParameter("SecurityIPList", securityIPList); +} + +std::string CreateInstanceRequest::getAutoRenew()const +{ + return autoRenew_; +} + +void CreateInstanceRequest::setAutoRenew(const std::string& autoRenew) +{ + autoRenew_ = autoRenew; + setCoreParameter("AutoRenew", autoRenew); +} + +std::string CreateInstanceRequest::getNetType()const +{ + return netType_; +} + +void CreateInstanceRequest::setNetType(const std::string& netType) +{ + netType_ = netType; + setCoreParameter("NetType", netType); +} + +std::string CreateInstanceRequest::getZoneId()const +{ + return zoneId_; +} + +void CreateInstanceRequest::setZoneId(const std::string& zoneId) +{ + zoneId_ = zoneId; + setCoreParameter("ZoneId", zoneId); +} + +std::string CreateInstanceRequest::getCoreDiskType()const +{ + return coreDiskType_; +} + +void CreateInstanceRequest::setCoreDiskType(const std::string& coreDiskType) +{ + coreDiskType_ = coreDiskType; + setCoreParameter("CoreDiskType", coreDiskType); +} + +std::string CreateInstanceRequest::getPricingCycle()const +{ + return pricingCycle_; +} + +void CreateInstanceRequest::setPricingCycle(const std::string& pricingCycle) +{ + pricingCycle_ = pricingCycle; + setCoreParameter("PricingCycle", pricingCycle); +} + +std::string CreateInstanceRequest::getCoreInstanceQuantity()const +{ + return coreInstanceQuantity_; +} + +void CreateInstanceRequest::setCoreInstanceQuantity(const std::string& coreInstanceQuantity) +{ + coreInstanceQuantity_ = coreInstanceQuantity; + setCoreParameter("CoreInstanceQuantity", coreInstanceQuantity); +} + +std::string CreateInstanceRequest::getDuration()const +{ + return duration_; +} + +void CreateInstanceRequest::setDuration(const std::string& duration) +{ + duration_ = duration; + setCoreParameter("Duration", duration); +} + +std::string CreateInstanceRequest::getRegionId()const +{ + return regionId_; +} + +void CreateInstanceRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setCoreParameter("RegionId", regionId); +} + +std::string CreateInstanceRequest::getEngine()const +{ + return engine_; +} + +void CreateInstanceRequest::setEngine(const std::string& engine) +{ + engine_ = engine; + setCoreParameter("Engine", engine); +} + +std::string CreateInstanceRequest::getRestoreTime()const +{ + return restoreTime_; +} + +void CreateInstanceRequest::setRestoreTime(const std::string& restoreTime) +{ + restoreTime_ = restoreTime; + setCoreParameter("RestoreTime", restoreTime); +} + +std::string CreateInstanceRequest::getSrcDBInstanceId()const +{ + return srcDBInstanceId_; +} + +void CreateInstanceRequest::setSrcDBInstanceId(const std::string& srcDBInstanceId) +{ + srcDBInstanceId_ = srcDBInstanceId; + setCoreParameter("SrcDBInstanceId", srcDBInstanceId); +} + +std::string CreateInstanceRequest::getMasterInstanceType()const +{ + return masterInstanceType_; +} + +void CreateInstanceRequest::setMasterInstanceType(const std::string& masterInstanceType) +{ + masterInstanceType_ = masterInstanceType; + setCoreParameter("MasterInstanceType", masterInstanceType); +} + +std::string CreateInstanceRequest::getColdStorageSize()const +{ + return coldStorageSize_; +} + +void CreateInstanceRequest::setColdStorageSize(const std::string& coldStorageSize) +{ + coldStorageSize_ = coldStorageSize; + setCoreParameter("ColdStorageSize", coldStorageSize); +} + +std::string CreateInstanceRequest::getCoreDiskQuantity()const +{ + return coreDiskQuantity_; +} + +void CreateInstanceRequest::setCoreDiskQuantity(const std::string& coreDiskQuantity) +{ + coreDiskQuantity_ = coreDiskQuantity; + setCoreParameter("CoreDiskQuantity", coreDiskQuantity); +} + +std::string CreateInstanceRequest::getIsColdStorage()const +{ + return isColdStorage_; +} + +void CreateInstanceRequest::setIsColdStorage(const std::string& isColdStorage) +{ + isColdStorage_ = isColdStorage; + setCoreParameter("IsColdStorage", isColdStorage); +} + +std::string CreateInstanceRequest::getCoreInstanceType()const +{ + return coreInstanceType_; +} + +void CreateInstanceRequest::setCoreInstanceType(const std::string& coreInstanceType) +{ + coreInstanceType_ = coreInstanceType; + setCoreParameter("CoreInstanceType", coreInstanceType); +} + +std::string CreateInstanceRequest::getCoreDiskSize()const +{ + return coreDiskSize_; +} + +void CreateInstanceRequest::setCoreDiskSize(const std::string& coreDiskSize) +{ + coreDiskSize_ = coreDiskSize; + setCoreParameter("CoreDiskSize", coreDiskSize); +} + +std::string CreateInstanceRequest::getVpcId()const +{ + return vpcId_; +} + +void CreateInstanceRequest::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; + setCoreParameter("VpcId", vpcId); +} + +std::string CreateInstanceRequest::getDbType()const +{ + return dbType_; +} + +void CreateInstanceRequest::setDbType(const std::string& dbType) +{ + dbType_ = dbType; + setCoreParameter("DbType", dbType); +} + +std::string CreateInstanceRequest::getPayType()const +{ + return payType_; +} + +void CreateInstanceRequest::setPayType(const std::string& payType) +{ + payType_ = payType; + setCoreParameter("PayType", payType); +} + diff --git a/hbase/src/model/CreateInstanceResult.cc b/hbase/src/model/CreateInstanceResult.cc new file mode 100644 index 000000000..06a13eca3 --- /dev/null +++ b/hbase/src/model/CreateInstanceResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::HBase; +using namespace AlibabaCloud::HBase::Model; + +CreateInstanceResult::CreateInstanceResult() : + ServiceResult() +{} + +CreateInstanceResult::CreateInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateInstanceResult::~CreateInstanceResult() +{} + +void CreateInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ClusterId"].isNull()) + clusterId_ = value["ClusterId"].asString(); + if(!value["OrderId"].isNull()) + orderId_ = value["OrderId"].asString(); + +} + +std::string CreateInstanceResult::getClusterId()const +{ + return clusterId_; +} + +std::string CreateInstanceResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/DeleteInstanceRequest.cc b/hbase/src/model/DeleteInstanceRequest.cc new file mode 100644 index 000000000..5491f78e5 --- /dev/null +++ b/hbase/src/model/DeleteInstanceRequest.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::DeleteInstanceRequest; + +DeleteInstanceRequest::DeleteInstanceRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DeleteInstance") +{ + setMethod(HttpRequest::Method::Post); +} + +DeleteInstanceRequest::~DeleteInstanceRequest() +{} + +std::string DeleteInstanceRequest::getClusterId()const +{ + return clusterId_; +} + +void DeleteInstanceRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/DeleteInstanceResult.cc b/hbase/src/model/DeleteInstanceResult.cc new file mode 100644 index 000000000..cc54aaa1c --- /dev/null +++ b/hbase/src/model/DeleteInstanceResult.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; + +DeleteInstanceResult::DeleteInstanceResult() : + ServiceResult() +{} + +DeleteInstanceResult::DeleteInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteInstanceResult::~DeleteInstanceResult() +{} + +void DeleteInstanceResult::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/DeleteUserHdfsInfoRequest.cc b/hbase/src/model/DeleteUserHdfsInfoRequest.cc new file mode 100644 index 000000000..0c52c951a --- /dev/null +++ b/hbase/src/model/DeleteUserHdfsInfoRequest.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::DeleteUserHdfsInfoRequest; + +DeleteUserHdfsInfoRequest::DeleteUserHdfsInfoRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DeleteUserHdfsInfo") +{ + setMethod(HttpRequest::Method::Post); +} + +DeleteUserHdfsInfoRequest::~DeleteUserHdfsInfoRequest() +{} + +std::string DeleteUserHdfsInfoRequest::getClusterId()const +{ + return clusterId_; +} + +void DeleteUserHdfsInfoRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string DeleteUserHdfsInfoRequest::getNameService()const +{ + return nameService_; +} + +void DeleteUserHdfsInfoRequest::setNameService(const std::string& nameService) +{ + nameService_ = nameService; + setCoreParameter("NameService", nameService); +} + diff --git a/hbase/src/model/DeleteUserHdfsInfoResult.cc b/hbase/src/model/DeleteUserHdfsInfoResult.cc new file mode 100644 index 000000000..ccb4a4151 --- /dev/null +++ b/hbase/src/model/DeleteUserHdfsInfoResult.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; + +DeleteUserHdfsInfoResult::DeleteUserHdfsInfoResult() : + ServiceResult() +{} + +DeleteUserHdfsInfoResult::DeleteUserHdfsInfoResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteUserHdfsInfoResult::~DeleteUserHdfsInfoResult() +{} + +void DeleteUserHdfsInfoResult::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/DescribeEndpointsRequest.cc b/hbase/src/model/DescribeEndpointsRequest.cc new file mode 100644 index 000000000..824308af6 --- /dev/null +++ b/hbase/src/model/DescribeEndpointsRequest.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::DescribeEndpointsRequest; + +DescribeEndpointsRequest::DescribeEndpointsRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DescribeEndpoints") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeEndpointsRequest::~DescribeEndpointsRequest() +{} + +std::string DescribeEndpointsRequest::getClusterId()const +{ + return clusterId_; +} + +void DescribeEndpointsRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/DescribeEndpointsResult.cc b/hbase/src/model/DescribeEndpointsResult.cc new file mode 100644 index 000000000..5a235ac43 --- /dev/null +++ b/hbase/src/model/DescribeEndpointsResult.cc @@ -0,0 +1,91 @@ +/* + * 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; + +DescribeEndpointsResult::DescribeEndpointsResult() : + ServiceResult() +{} + +DescribeEndpointsResult::DescribeEndpointsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeEndpointsResult::~DescribeEndpointsResult() +{} + +void DescribeEndpointsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allConnAddrsNode = value["ConnAddrs"]["ConnAddrInfo"]; + for (auto valueConnAddrsConnAddrInfo : allConnAddrsNode) + { + ConnAddrInfo connAddrsObject; + if(!valueConnAddrsConnAddrInfo["ConnType"].isNull()) + connAddrsObject.connType = valueConnAddrsConnAddrInfo["ConnType"].asString(); + if(!valueConnAddrsConnAddrInfo["ConnAddr"].isNull()) + connAddrsObject.connAddr = valueConnAddrsConnAddrInfo["ConnAddr"].asString(); + if(!valueConnAddrsConnAddrInfo["ConnAddrPort"].isNull()) + connAddrsObject.connAddrPort = valueConnAddrsConnAddrInfo["ConnAddrPort"].asString(); + if(!valueConnAddrsConnAddrInfo["NetType"].isNull()) + connAddrsObject.netType = valueConnAddrsConnAddrInfo["NetType"].asString(); + connAddrs_.push_back(connAddrsObject); + } + if(!value["NetType"].isNull()) + netType_ = value["NetType"].asString(); + if(!value["VpcId"].isNull()) + vpcId_ = value["VpcId"].asString(); + if(!value["VSwitchId"].isNull()) + vSwitchId_ = value["VSwitchId"].asString(); + if(!value["Engine"].isNull()) + engine_ = value["Engine"].asString(); + +} + +std::string DescribeEndpointsResult::getVpcId()const +{ + return vpcId_; +} + +std::vector DescribeEndpointsResult::getConnAddrs()const +{ + return connAddrs_; +} + +std::string DescribeEndpointsResult::getVSwitchId()const +{ + return vSwitchId_; +} + +std::string DescribeEndpointsResult::getNetType()const +{ + return netType_; +} + +std::string DescribeEndpointsResult::getEngine()const +{ + return engine_; +} + diff --git a/hbase/src/model/DescribeInstanceRequest.cc b/hbase/src/model/DescribeInstanceRequest.cc new file mode 100644 index 000000000..e346e81f4 --- /dev/null +++ b/hbase/src/model/DescribeInstanceRequest.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::DescribeInstanceRequest; + +DescribeInstanceRequest::DescribeInstanceRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DescribeInstance") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeInstanceRequest::~DescribeInstanceRequest() +{} + +std::string DescribeInstanceRequest::getClusterId()const +{ + return clusterId_; +} + +void DescribeInstanceRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/DescribeInstanceResult.cc b/hbase/src/model/DescribeInstanceResult.cc new file mode 100644 index 000000000..1c6facfb7 --- /dev/null +++ b/hbase/src/model/DescribeInstanceResult.cc @@ -0,0 +1,241 @@ +/* + * 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; + +DescribeInstanceResult::DescribeInstanceResult() : + ServiceResult() +{} + +DescribeInstanceResult::DescribeInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeInstanceResult::~DescribeInstanceResult() +{} + +void DescribeInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + 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["InstanceId"].isNull()) + instanceId_ = value["InstanceId"].asString(); + if(!value["InstanceName"].isNull()) + instanceName_ = value["InstanceName"].asString(); + if(!value["Status"].isNull()) + status_ = value["Status"].asString(); + if(!value["PayType"].isNull()) + payType_ = value["PayType"].asString(); + if(!value["CreatedTime"].isNull()) + createdTime_ = value["CreatedTime"].asString(); + if(!value["ExpireTime"].isNull()) + expireTime_ = value["ExpireTime"].asString(); + if(!value["MajorVersion"].isNull()) + majorVersion_ = value["MajorVersion"].asString(); + if(!value["MinorVersion"].isNull()) + minorVersion_ = value["MinorVersion"].asString(); + if(!value["Engine"].isNull()) + engine_ = value["Engine"].asString(); + if(!value["IsHa"].isNull()) + isHa_ = value["IsHa"].asString() == "true"; + if(!value["NetworkType"].isNull()) + networkType_ = value["NetworkType"].asString(); + if(!value["VpcId"].isNull()) + vpcId_ = value["VpcId"].asString(); + if(!value["VswitchId"].isNull()) + vswitchId_ = value["VswitchId"].asString(); + if(!value["MasterInstanceType"].isNull()) + masterInstanceType_ = value["MasterInstanceType"].asString(); + if(!value["MasterNodeCount"].isNull()) + masterNodeCount_ = std::stoi(value["MasterNodeCount"].asString()); + if(!value["MasterDiskType"].isNull()) + masterDiskType_ = value["MasterDiskType"].asString(); + if(!value["MasterDiskSize"].isNull()) + masterDiskSize_ = std::stoi(value["MasterDiskSize"].asString()); + if(!value["CoreInstanceType"].isNull()) + coreInstanceType_ = value["CoreInstanceType"].asString(); + if(!value["CoreNodeCount"].isNull()) + coreNodeCount_ = std::stoi(value["CoreNodeCount"].asString()); + if(!value["CoreDiskType"].isNull()) + coreDiskType_ = value["CoreDiskType"].asString(); + if(!value["CoreDiskSize"].isNull()) + coreDiskSize_ = std::stoi(value["CoreDiskSize"].asString()); + if(!value["RegionId"].isNull()) + regionId_ = value["RegionId"].asString(); + if(!value["ZoneId"].isNull()) + zoneId_ = value["ZoneId"].asString(); + if(!value["ColdStorageStatus"].isNull()) + coldStorageStatus_ = value["ColdStorageStatus"].asString(); + if(!value["BackupStatus"].isNull()) + backupStatus_ = value["BackupStatus"].asString(); + if(!value["CoreDiskCount"].isNull()) + coreDiskCount_ = value["CoreDiskCount"].asString(); + +} + +bool DescribeInstanceResult::getIsHa()const +{ + return isHa_; +} + +std::string DescribeInstanceResult::getCreatedTime()const +{ + return createdTime_; +} + +std::string DescribeInstanceResult::getMasterInstanceType()const +{ + return masterInstanceType_; +} + +std::string DescribeInstanceResult::getNetworkType()const +{ + return networkType_; +} + +std::string DescribeInstanceResult::getCoreInstanceType()const +{ + return coreInstanceType_; +} + +std::string DescribeInstanceResult::getMasterDiskType()const +{ + return masterDiskType_; +} + +std::vector DescribeInstanceResult::getTags()const +{ + return tags_; +} + +std::string DescribeInstanceResult::getEngine()const +{ + return engine_; +} + +std::string DescribeInstanceResult::getStatus()const +{ + return status_; +} + +std::string DescribeInstanceResult::getMajorVersion()const +{ + return majorVersion_; +} + +std::string DescribeInstanceResult::getCoreDiskCount()const +{ + return coreDiskCount_; +} + +int DescribeInstanceResult::getMasterDiskSize()const +{ + return masterDiskSize_; +} + +std::string DescribeInstanceResult::getZoneId()const +{ + return zoneId_; +} + +std::string DescribeInstanceResult::getInstanceId()const +{ + return instanceId_; +} + +int DescribeInstanceResult::getCoreNodeCount()const +{ + return coreNodeCount_; +} + +std::string DescribeInstanceResult::getColdStorageStatus()const +{ + return coldStorageStatus_; +} + +std::string DescribeInstanceResult::getMinorVersion()const +{ + return minorVersion_; +} + +std::string DescribeInstanceResult::getPayType()const +{ + return payType_; +} + +std::string DescribeInstanceResult::getVswitchId()const +{ + return vswitchId_; +} + +std::string DescribeInstanceResult::getInstanceName()const +{ + return instanceName_; +} + +int DescribeInstanceResult::getMasterNodeCount()const +{ + return masterNodeCount_; +} + +std::string DescribeInstanceResult::getVpcId()const +{ + return vpcId_; +} + +std::string DescribeInstanceResult::getCoreDiskType()const +{ + return coreDiskType_; +} + +std::string DescribeInstanceResult::getRegionId()const +{ + return regionId_; +} + +std::string DescribeInstanceResult::getExpireTime()const +{ + return expireTime_; +} + +int DescribeInstanceResult::getCoreDiskSize()const +{ + return coreDiskSize_; +} + +std::string DescribeInstanceResult::getBackupStatus()const +{ + return backupStatus_; +} + diff --git a/hbase/src/model/DescribeInstancesRequest.cc b/hbase/src/model/DescribeInstancesRequest.cc new file mode 100644 index 000000000..2e009ade2 --- /dev/null +++ b/hbase/src/model/DescribeInstancesRequest.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::DescribeInstancesRequest; + +DescribeInstancesRequest::DescribeInstancesRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DescribeInstances") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeInstancesRequest::~DescribeInstancesRequest() +{} + +int DescribeInstancesRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeInstancesRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setCoreParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeInstancesRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeInstancesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setCoreParameter("RegionId", regionId); +} + +int DescribeInstancesRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeInstancesRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setCoreParameter("PageSize", std::to_string(pageSize)); +} + diff --git a/hbase/src/model/DescribeInstancesResult.cc b/hbase/src/model/DescribeInstancesResult.cc new file mode 100644 index 000000000..31f982168 --- /dev/null +++ b/hbase/src/model/DescribeInstancesResult.cc @@ -0,0 +1,124 @@ +/* + * 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; + +DescribeInstancesResult::DescribeInstancesResult() : + ServiceResult() +{} + +DescribeInstancesResult::DescribeInstancesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeInstancesResult::~DescribeInstancesResult() +{} + +void DescribeInstancesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allInstancesNode = value["Instances"]["Instance"]; + for (auto valueInstancesInstance : allInstancesNode) + { + Instance instancesObject; + if(!valueInstancesInstance["InstanceId"].isNull()) + instancesObject.instanceId = valueInstancesInstance["InstanceId"].asString(); + if(!valueInstancesInstance["InstanceName"].isNull()) + instancesObject.instanceName = valueInstancesInstance["InstanceName"].asString(); + if(!valueInstancesInstance["Status"].isNull()) + instancesObject.status = valueInstancesInstance["Status"].asString(); + if(!valueInstancesInstance["PayType"].isNull()) + instancesObject.payType = valueInstancesInstance["PayType"].asString(); + if(!valueInstancesInstance["CreatedTime"].isNull()) + instancesObject.createdTime = valueInstancesInstance["CreatedTime"].asString(); + if(!valueInstancesInstance["ExpireTime"].isNull()) + instancesObject.expireTime = valueInstancesInstance["ExpireTime"].asString(); + if(!valueInstancesInstance["MajorVersion"].isNull()) + instancesObject.majorVersion = valueInstancesInstance["MajorVersion"].asString(); + if(!valueInstancesInstance["Engine"].isNull()) + instancesObject.engine = valueInstancesInstance["Engine"].asString(); + if(!valueInstancesInstance["IsHa"].isNull()) + instancesObject.isHa = valueInstancesInstance["IsHa"].asString() == "true"; + if(!valueInstancesInstance["NetworkType"].isNull()) + instancesObject.networkType = valueInstancesInstance["NetworkType"].asString(); + if(!valueInstancesInstance["VpcId"].isNull()) + instancesObject.vpcId = valueInstancesInstance["VpcId"].asString(); + if(!valueInstancesInstance["VswitchId"].isNull()) + instancesObject.vswitchId = valueInstancesInstance["VswitchId"].asString(); + if(!valueInstancesInstance["MasterInstanceType"].isNull()) + instancesObject.masterInstanceType = valueInstancesInstance["MasterInstanceType"].asString(); + if(!valueInstancesInstance["MasterNodeCount"].isNull()) + instancesObject.masterNodeCount = std::stoi(valueInstancesInstance["MasterNodeCount"].asString()); + if(!valueInstancesInstance["MasterDiskType"].isNull()) + instancesObject.masterDiskType = valueInstancesInstance["MasterDiskType"].asString(); + if(!valueInstancesInstance["MasterDiskSize"].isNull()) + instancesObject.masterDiskSize = std::stoi(valueInstancesInstance["MasterDiskSize"].asString()); + if(!valueInstancesInstance["CoreInstanceType"].isNull()) + instancesObject.coreInstanceType = valueInstancesInstance["CoreInstanceType"].asString(); + if(!valueInstancesInstance["CoreNodeCount"].isNull()) + instancesObject.coreNodeCount = std::stoi(valueInstancesInstance["CoreNodeCount"].asString()); + if(!valueInstancesInstance["CoreDiskType"].isNull()) + instancesObject.coreDiskType = valueInstancesInstance["CoreDiskType"].asString(); + if(!valueInstancesInstance["CoreDiskSize"].isNull()) + instancesObject.coreDiskSize = std::stoi(valueInstancesInstance["CoreDiskSize"].asString()); + if(!valueInstancesInstance["RegionId"].isNull()) + instancesObject.regionId = valueInstancesInstance["RegionId"].asString(); + if(!valueInstancesInstance["ZoneId"].isNull()) + instancesObject.zoneId = valueInstancesInstance["ZoneId"].asString(); + if(!valueInstancesInstance["ColdStorageStatus"].isNull()) + instancesObject.coldStorageStatus = valueInstancesInstance["ColdStorageStatus"].asString(); + if(!valueInstancesInstance["BackupStatus"].isNull()) + instancesObject.backupStatus = valueInstancesInstance["BackupStatus"].asString(); + instances_.push_back(instancesObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + +} + +std::vector DescribeInstancesResult::getInstances()const +{ + return instances_; +} + +long DescribeInstancesResult::getTotalCount()const +{ + return totalCount_; +} + +int DescribeInstancesResult::getPageSize()const +{ + return pageSize_; +} + +int DescribeInstancesResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/hbase/src/model/DescribeIpWhitelistRequest.cc b/hbase/src/model/DescribeIpWhitelistRequest.cc new file mode 100644 index 000000000..d7be16596 --- /dev/null +++ b/hbase/src/model/DescribeIpWhitelistRequest.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::DescribeIpWhitelistRequest; + +DescribeIpWhitelistRequest::DescribeIpWhitelistRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DescribeIpWhitelist") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeIpWhitelistRequest::~DescribeIpWhitelistRequest() +{} + +std::string DescribeIpWhitelistRequest::getClusterId()const +{ + return clusterId_; +} + +void DescribeIpWhitelistRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/DescribeIpWhitelistResult.cc b/hbase/src/model/DescribeIpWhitelistResult.cc new file mode 100644 index 000000000..c549356e5 --- /dev/null +++ b/hbase/src/model/DescribeIpWhitelistResult.cc @@ -0,0 +1,52 @@ +/* + * 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; + +DescribeIpWhitelistResult::DescribeIpWhitelistResult() : + ServiceResult() +{} + +DescribeIpWhitelistResult::DescribeIpWhitelistResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeIpWhitelistResult::~DescribeIpWhitelistResult() +{} + +void DescribeIpWhitelistResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allIpList = value["IpList"]["IP"]; + for (const auto &item : allIpList) + ipList_.push_back(item.asString()); + +} + +std::vector DescribeIpWhitelistResult::getIpList()const +{ + return ipList_; +} + diff --git a/hbase/src/model/DescribeRegionsRequest.cc b/hbase/src/model/DescribeRegionsRequest.cc new file mode 100644 index 000000000..88a49e107 --- /dev/null +++ b/hbase/src/model/DescribeRegionsRequest.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::DescribeRegionsRequest; + +DescribeRegionsRequest::DescribeRegionsRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DescribeRegions") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeRegionsRequest::~DescribeRegionsRequest() +{} + +std::string DescribeRegionsRequest::getAcceptLanguage()const +{ + return acceptLanguage_; +} + +void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage) +{ + acceptLanguage_ = acceptLanguage; + setCoreParameter("AcceptLanguage", acceptLanguage); +} + diff --git a/hbase/src/model/DescribeRegionsResult.cc b/hbase/src/model/DescribeRegionsResult.cc new file mode 100644 index 000000000..6680b0472 --- /dev/null +++ b/hbase/src/model/DescribeRegionsResult.cc @@ -0,0 +1,69 @@ +/* + * 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; + +DescribeRegionsResult::DescribeRegionsResult() : + ServiceResult() +{} + +DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeRegionsResult::~DescribeRegionsResult() +{} + +void DescribeRegionsResult::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["RegionId"].isNull()) + regionsObject.regionId = valueRegionsRegion["RegionId"].asString(); + if(!valueRegionsRegion["LocalName"].isNull()) + regionsObject.localName = valueRegionsRegion["LocalName"].asString(); + if(!valueRegionsRegion["RegionEndpoint"].isNull()) + regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString(); + auto allZonesNode = allRegionsNode["Zones"]["Zone"]; + for (auto allRegionsNodeZonesZone : allZonesNode) + { + Region::Zone zonesObject; + if(!allRegionsNodeZonesZone["Id"].isNull()) + zonesObject.id = allRegionsNodeZonesZone["Id"].asString(); + regionsObject.zones.push_back(zonesObject); + } + regions_.push_back(regionsObject); + } + +} + +std::vector DescribeRegionsResult::getRegions()const +{ + return regions_; +} + diff --git a/hbase/src/model/DescribeSecurityGroupsRequest.cc b/hbase/src/model/DescribeSecurityGroupsRequest.cc new file mode 100644 index 000000000..4bafa1ccc --- /dev/null +++ b/hbase/src/model/DescribeSecurityGroupsRequest.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::DescribeSecurityGroupsRequest; + +DescribeSecurityGroupsRequest::DescribeSecurityGroupsRequest() : + RpcServiceRequest("hbase", "2019-01-01", "DescribeSecurityGroups") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeSecurityGroupsRequest::~DescribeSecurityGroupsRequest() +{} + +std::string DescribeSecurityGroupsRequest::getClusterId()const +{ + return clusterId_; +} + +void DescribeSecurityGroupsRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/DescribeSecurityGroupsResult.cc b/hbase/src/model/DescribeSecurityGroupsResult.cc new file mode 100644 index 000000000..d7a1c9591 --- /dev/null +++ b/hbase/src/model/DescribeSecurityGroupsResult.cc @@ -0,0 +1,52 @@ +/* + * 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; + +DescribeSecurityGroupsResult::DescribeSecurityGroupsResult() : + ServiceResult() +{} + +DescribeSecurityGroupsResult::DescribeSecurityGroupsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeSecurityGroupsResult::~DescribeSecurityGroupsResult() +{} + +void DescribeSecurityGroupsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allSecurityGroupIds = value["SecurityGroupIds"]["SecurityGroupId"]; + for (const auto &item : allSecurityGroupIds) + securityGroupIds_.push_back(item.asString()); + +} + +std::vector DescribeSecurityGroupsResult::getSecurityGroupIds()const +{ + return securityGroupIds_; +} + diff --git a/hbase/src/model/ModifyInstanceNameRequest.cc b/hbase/src/model/ModifyInstanceNameRequest.cc new file mode 100644 index 000000000..81f59a609 --- /dev/null +++ b/hbase/src/model/ModifyInstanceNameRequest.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::ModifyInstanceNameRequest; + +ModifyInstanceNameRequest::ModifyInstanceNameRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ModifyInstanceName") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifyInstanceNameRequest::~ModifyInstanceNameRequest() +{} + +std::string ModifyInstanceNameRequest::getClientToken()const +{ + return clientToken_; +} + +void ModifyInstanceNameRequest::setClientToken(const std::string& clientToken) +{ + clientToken_ = clientToken; + setCoreParameter("ClientToken", clientToken); +} + +std::string ModifyInstanceNameRequest::getClusterName()const +{ + return clusterName_; +} + +void ModifyInstanceNameRequest::setClusterName(const std::string& clusterName) +{ + clusterName_ = clusterName; + setCoreParameter("ClusterName", clusterName); +} + +std::string ModifyInstanceNameRequest::getClusterId()const +{ + return clusterId_; +} + +void ModifyInstanceNameRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string ModifyInstanceNameRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyInstanceNameRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string ModifyInstanceNameRequest::getRegionId()const +{ + return regionId_; +} + +void ModifyInstanceNameRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setCoreParameter("RegionId", regionId); +} + +std::string ModifyInstanceNameRequest::getZoneId()const +{ + return zoneId_; +} + +void ModifyInstanceNameRequest::setZoneId(const std::string& zoneId) +{ + zoneId_ = zoneId; + setCoreParameter("ZoneId", zoneId); +} + diff --git a/hbase/src/model/ModifyInstanceNameResult.cc b/hbase/src/model/ModifyInstanceNameResult.cc new file mode 100644 index 000000000..c1b12332c --- /dev/null +++ b/hbase/src/model/ModifyInstanceNameResult.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; + +ModifyInstanceNameResult::ModifyInstanceNameResult() : + ServiceResult() +{} + +ModifyInstanceNameResult::ModifyInstanceNameResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyInstanceNameResult::~ModifyInstanceNameResult() +{} + +void ModifyInstanceNameResult::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/ModifyIpWhitelistRequest.cc b/hbase/src/model/ModifyIpWhitelistRequest.cc new file mode 100644 index 000000000..8733e3ba2 --- /dev/null +++ b/hbase/src/model/ModifyIpWhitelistRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::HBase::Model::ModifyIpWhitelistRequest; + +ModifyIpWhitelistRequest::ModifyIpWhitelistRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ModifyIpWhitelist") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifyIpWhitelistRequest::~ModifyIpWhitelistRequest() +{} + +std::string ModifyIpWhitelistRequest::getIpList()const +{ + return ipList_; +} + +void ModifyIpWhitelistRequest::setIpList(const std::string& ipList) +{ + ipList_ = ipList; + setCoreParameter("IpList", ipList); +} + +std::string ModifyIpWhitelistRequest::getIpVersion()const +{ + return ipVersion_; +} + +void ModifyIpWhitelistRequest::setIpVersion(const std::string& ipVersion) +{ + ipVersion_ = ipVersion; + setCoreParameter("IpVersion", ipVersion); +} + +std::string ModifyIpWhitelistRequest::getClusterId()const +{ + return clusterId_; +} + +void ModifyIpWhitelistRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string ModifyIpWhitelistRequest::getGroupName()const +{ + return groupName_; +} + +void ModifyIpWhitelistRequest::setGroupName(const std::string& groupName) +{ + groupName_ = groupName; + setCoreParameter("GroupName", groupName); +} + diff --git a/hbase/src/model/ModifyIpWhitelistResult.cc b/hbase/src/model/ModifyIpWhitelistResult.cc new file mode 100644 index 000000000..34629a8b8 --- /dev/null +++ b/hbase/src/model/ModifyIpWhitelistResult.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; + +ModifyIpWhitelistResult::ModifyIpWhitelistResult() : + ServiceResult() +{} + +ModifyIpWhitelistResult::ModifyIpWhitelistResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyIpWhitelistResult::~ModifyIpWhitelistResult() +{} + +void ModifyIpWhitelistResult::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/ModifySecurityGroupsRequest.cc b/hbase/src/model/ModifySecurityGroupsRequest.cc new file mode 100644 index 000000000..db3a522b4 --- /dev/null +++ b/hbase/src/model/ModifySecurityGroupsRequest.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::ModifySecurityGroupsRequest; + +ModifySecurityGroupsRequest::ModifySecurityGroupsRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ModifySecurityGroups") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifySecurityGroupsRequest::~ModifySecurityGroupsRequest() +{} + +std::string ModifySecurityGroupsRequest::getClusterId()const +{ + return clusterId_; +} + +void ModifySecurityGroupsRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string ModifySecurityGroupsRequest::getSecurityGroupIds()const +{ + return securityGroupIds_; +} + +void ModifySecurityGroupsRequest::setSecurityGroupIds(const std::string& securityGroupIds) +{ + securityGroupIds_ = securityGroupIds; + setCoreParameter("SecurityGroupIds", securityGroupIds); +} + diff --git a/hbase/src/model/ModifySecurityGroupsResult.cc b/hbase/src/model/ModifySecurityGroupsResult.cc new file mode 100644 index 000000000..4f6a1fa2c --- /dev/null +++ b/hbase/src/model/ModifySecurityGroupsResult.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; + +ModifySecurityGroupsResult::ModifySecurityGroupsResult() : + ServiceResult() +{} + +ModifySecurityGroupsResult::ModifySecurityGroupsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifySecurityGroupsResult::~ModifySecurityGroupsResult() +{} + +void ModifySecurityGroupsResult::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/ModifyUIAccountPasswordRequest.cc b/hbase/src/model/ModifyUIAccountPasswordRequest.cc new file mode 100644 index 000000000..ee89d1990 --- /dev/null +++ b/hbase/src/model/ModifyUIAccountPasswordRequest.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::ModifyUIAccountPasswordRequest; + +ModifyUIAccountPasswordRequest::ModifyUIAccountPasswordRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ModifyUIAccountPassword") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifyUIAccountPasswordRequest::~ModifyUIAccountPasswordRequest() +{} + +std::string ModifyUIAccountPasswordRequest::getClusterId()const +{ + return clusterId_; +} + +void ModifyUIAccountPasswordRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string ModifyUIAccountPasswordRequest::getAccountPassword()const +{ + return accountPassword_; +} + +void ModifyUIAccountPasswordRequest::setAccountPassword(const std::string& accountPassword) +{ + accountPassword_ = accountPassword; + setCoreParameter("AccountPassword", accountPassword); +} + +std::string ModifyUIAccountPasswordRequest::getAccountName()const +{ + return accountName_; +} + +void ModifyUIAccountPasswordRequest::setAccountName(const std::string& accountName) +{ + accountName_ = accountName; + setCoreParameter("AccountName", accountName); +} + diff --git a/hbase/src/model/ModifyUIAccountPasswordResult.cc b/hbase/src/model/ModifyUIAccountPasswordResult.cc new file mode 100644 index 000000000..3c33ebba9 --- /dev/null +++ b/hbase/src/model/ModifyUIAccountPasswordResult.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; + +ModifyUIAccountPasswordResult::ModifyUIAccountPasswordResult() : + ServiceResult() +{} + +ModifyUIAccountPasswordResult::ModifyUIAccountPasswordResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyUIAccountPasswordResult::~ModifyUIAccountPasswordResult() +{} + +void ModifyUIAccountPasswordResult::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/QueryXpackRelateDBRequest.cc b/hbase/src/model/QueryXpackRelateDBRequest.cc new file mode 100644 index 000000000..742df91fc --- /dev/null +++ b/hbase/src/model/QueryXpackRelateDBRequest.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::QueryXpackRelateDBRequest; + +QueryXpackRelateDBRequest::QueryXpackRelateDBRequest() : + RpcServiceRequest("hbase", "2019-01-01", "QueryXpackRelateDB") +{ + setMethod(HttpRequest::Method::Post); +} + +QueryXpackRelateDBRequest::~QueryXpackRelateDBRequest() +{} + +std::string QueryXpackRelateDBRequest::getClusterId()const +{ + return clusterId_; +} + +void QueryXpackRelateDBRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string QueryXpackRelateDBRequest::getRelateDbType()const +{ + return relateDbType_; +} + +void QueryXpackRelateDBRequest::setRelateDbType(const std::string& relateDbType) +{ + relateDbType_ = relateDbType; + setCoreParameter("RelateDbType", relateDbType); +} + diff --git a/hbase/src/model/QueryXpackRelateDBResult.cc b/hbase/src/model/QueryXpackRelateDBResult.cc new file mode 100644 index 000000000..786e35e3c --- /dev/null +++ b/hbase/src/model/QueryXpackRelateDBResult.cc @@ -0,0 +1,69 @@ +/* + * 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; + +QueryXpackRelateDBResult::QueryXpackRelateDBResult() : + ServiceResult() +{} + +QueryXpackRelateDBResult::QueryXpackRelateDBResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryXpackRelateDBResult::~QueryXpackRelateDBResult() +{} + +void QueryXpackRelateDBResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allClusterListNode = value["ClusterList"]["Cluster"]; + for (auto valueClusterListCluster : allClusterListNode) + { + Cluster clusterListObject; + if(!valueClusterListCluster["ClusterId"].isNull()) + clusterListObject.clusterId = valueClusterListCluster["ClusterId"].asString(); + if(!valueClusterListCluster["ClusterName"].isNull()) + clusterListObject.clusterName = valueClusterListCluster["ClusterName"].asString(); + if(!valueClusterListCluster["DBVersion"].isNull()) + clusterListObject.dBVersion = valueClusterListCluster["DBVersion"].asString(); + if(!valueClusterListCluster["Status"].isNull()) + clusterListObject.status = valueClusterListCluster["Status"].asString(); + if(!valueClusterListCluster["DBType"].isNull()) + clusterListObject.dBType = valueClusterListCluster["DBType"].asString(); + if(!valueClusterListCluster["IsRelated"].isNull()) + clusterListObject.isRelated = valueClusterListCluster["IsRelated"].asString() == "true"; + if(!valueClusterListCluster["LockMode"].isNull()) + clusterListObject.lockMode = valueClusterListCluster["LockMode"].asString(); + clusterList_.push_back(clusterListObject); + } + +} + +std::vector QueryXpackRelateDBResult::getClusterList()const +{ + return clusterList_; +} + diff --git a/hbase/src/model/RenewInstanceRequest.cc b/hbase/src/model/RenewInstanceRequest.cc new file mode 100644 index 000000000..e4ba8a009 --- /dev/null +++ b/hbase/src/model/RenewInstanceRequest.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::RenewInstanceRequest; + +RenewInstanceRequest::RenewInstanceRequest() : + RpcServiceRequest("hbase", "2019-01-01", "RenewInstance") +{ + setMethod(HttpRequest::Method::Post); +} + +RenewInstanceRequest::~RenewInstanceRequest() +{} + +std::string RenewInstanceRequest::getClusterId()const +{ + return clusterId_; +} + +void RenewInstanceRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int RenewInstanceRequest::getDuration()const +{ + return duration_; +} + +void RenewInstanceRequest::setDuration(int duration) +{ + duration_ = duration; + setCoreParameter("Duration", std::to_string(duration)); +} + +std::string RenewInstanceRequest::getPricingCycle()const +{ + return pricingCycle_; +} + +void RenewInstanceRequest::setPricingCycle(const std::string& pricingCycle) +{ + pricingCycle_ = pricingCycle; + setCoreParameter("PricingCycle", pricingCycle); +} + diff --git a/hbase/src/model/RenewInstanceResult.cc b/hbase/src/model/RenewInstanceResult.cc new file mode 100644 index 000000000..72a45e16d --- /dev/null +++ b/hbase/src/model/RenewInstanceResult.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; + +RenewInstanceResult::RenewInstanceResult() : + ServiceResult() +{} + +RenewInstanceResult::RenewInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RenewInstanceResult::~RenewInstanceResult() +{} + +void RenewInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = std::stol(value["OrderId"].asString()); + +} + +long RenewInstanceResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/ResizeDiskSizeRequest.cc b/hbase/src/model/ResizeDiskSizeRequest.cc new file mode 100644 index 000000000..f2b2adce2 --- /dev/null +++ b/hbase/src/model/ResizeDiskSizeRequest.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::ResizeDiskSizeRequest; + +ResizeDiskSizeRequest::ResizeDiskSizeRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ResizeDiskSize") +{ + setMethod(HttpRequest::Method::Post); +} + +ResizeDiskSizeRequest::~ResizeDiskSizeRequest() +{} + +int ResizeDiskSizeRequest::getNodeDiskSize()const +{ + return nodeDiskSize_; +} + +void ResizeDiskSizeRequest::setNodeDiskSize(int nodeDiskSize) +{ + nodeDiskSize_ = nodeDiskSize; + setCoreParameter("NodeDiskSize", std::to_string(nodeDiskSize)); +} + +std::string ResizeDiskSizeRequest::getClusterId()const +{ + return clusterId_; +} + +void ResizeDiskSizeRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/ResizeDiskSizeResult.cc b/hbase/src/model/ResizeDiskSizeResult.cc new file mode 100644 index 000000000..13791f90b --- /dev/null +++ b/hbase/src/model/ResizeDiskSizeResult.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; + +ResizeDiskSizeResult::ResizeDiskSizeResult() : + ServiceResult() +{} + +ResizeDiskSizeResult::ResizeDiskSizeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ResizeDiskSizeResult::~ResizeDiskSizeResult() +{} + +void ResizeDiskSizeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = value["OrderId"].asString(); + +} + +std::string ResizeDiskSizeResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/ResizeNodeCountRequest.cc b/hbase/src/model/ResizeNodeCountRequest.cc new file mode 100644 index 000000000..d1ccc1d33 --- /dev/null +++ b/hbase/src/model/ResizeNodeCountRequest.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::ResizeNodeCountRequest; + +ResizeNodeCountRequest::ResizeNodeCountRequest() : + RpcServiceRequest("hbase", "2019-01-01", "ResizeNodeCount") +{ + setMethod(HttpRequest::Method::Post); +} + +ResizeNodeCountRequest::~ResizeNodeCountRequest() +{} + +std::string ResizeNodeCountRequest::getClusterId()const +{ + return clusterId_; +} + +void ResizeNodeCountRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +int ResizeNodeCountRequest::getNodeCount()const +{ + return nodeCount_; +} + +void ResizeNodeCountRequest::setNodeCount(int nodeCount) +{ + nodeCount_ = nodeCount; + setCoreParameter("NodeCount", std::to_string(nodeCount)); +} + diff --git a/hbase/src/model/ResizeNodeCountResult.cc b/hbase/src/model/ResizeNodeCountResult.cc new file mode 100644 index 000000000..9602eb313 --- /dev/null +++ b/hbase/src/model/ResizeNodeCountResult.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; + +ResizeNodeCountResult::ResizeNodeCountResult() : + ServiceResult() +{} + +ResizeNodeCountResult::ResizeNodeCountResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ResizeNodeCountResult::~ResizeNodeCountResult() +{} + +void ResizeNodeCountResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["OrderId"].isNull()) + orderId_ = value["OrderId"].asString(); + +} + +std::string ResizeNodeCountResult::getOrderId()const +{ + return orderId_; +} + diff --git a/hbase/src/model/RestartInstanceRequest.cc b/hbase/src/model/RestartInstanceRequest.cc new file mode 100644 index 000000000..ca03900a0 --- /dev/null +++ b/hbase/src/model/RestartInstanceRequest.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::RestartInstanceRequest; + +RestartInstanceRequest::RestartInstanceRequest() : + RpcServiceRequest("hbase", "2019-01-01", "RestartInstance") +{ + setMethod(HttpRequest::Method::Post); +} + +RestartInstanceRequest::~RestartInstanceRequest() +{} + +std::string RestartInstanceRequest::getComponents()const +{ + return components_; +} + +void RestartInstanceRequest::setComponents(const std::string& components) +{ + components_ = components; + setCoreParameter("Components", components); +} + +std::string RestartInstanceRequest::getClusterId()const +{ + return clusterId_; +} + +void RestartInstanceRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + diff --git a/hbase/src/model/RestartInstanceResult.cc b/hbase/src/model/RestartInstanceResult.cc new file mode 100644 index 000000000..cc5363cfd --- /dev/null +++ b/hbase/src/model/RestartInstanceResult.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; + +RestartInstanceResult::RestartInstanceResult() : + ServiceResult() +{} + +RestartInstanceResult::RestartInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RestartInstanceResult::~RestartInstanceResult() +{} + +void RestartInstanceResult::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/XpackRelateDBRequest.cc b/hbase/src/model/XpackRelateDBRequest.cc new file mode 100644 index 000000000..3bdc53ba1 --- /dev/null +++ b/hbase/src/model/XpackRelateDBRequest.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::XpackRelateDBRequest; + +XpackRelateDBRequest::XpackRelateDBRequest() : + RpcServiceRequest("hbase", "2019-01-01", "XpackRelateDB") +{ + setMethod(HttpRequest::Method::Post); +} + +XpackRelateDBRequest::~XpackRelateDBRequest() +{} + +std::string XpackRelateDBRequest::getClusterId()const +{ + return clusterId_; +} + +void XpackRelateDBRequest::setClusterId(const std::string& clusterId) +{ + clusterId_ = clusterId; + setCoreParameter("ClusterId", clusterId); +} + +std::string XpackRelateDBRequest::getRelateDbType()const +{ + return relateDbType_; +} + +void XpackRelateDBRequest::setRelateDbType(const std::string& relateDbType) +{ + relateDbType_ = relateDbType; + setCoreParameter("RelateDbType", relateDbType); +} + +std::string XpackRelateDBRequest::getDbClusterIds()const +{ + return dbClusterIds_; +} + +void XpackRelateDBRequest::setDbClusterIds(const std::string& dbClusterIds) +{ + dbClusterIds_ = dbClusterIds; + setCoreParameter("DbClusterIds", dbClusterIds); +} + diff --git a/hbase/src/model/XpackRelateDBResult.cc b/hbase/src/model/XpackRelateDBResult.cc new file mode 100644 index 000000000..3fd48b8a4 --- /dev/null +++ b/hbase/src/model/XpackRelateDBResult.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; + +XpackRelateDBResult::XpackRelateDBResult() : + ServiceResult() +{} + +XpackRelateDBResult::XpackRelateDBResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +XpackRelateDBResult::~XpackRelateDBResult() +{} + +void XpackRelateDBResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} +