diff --git a/VERSION b/VERSION index f8f4fafe6..6ba25ff0e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1717 \ No newline at end of file +1.36.1718 \ No newline at end of file diff --git a/adcp/CMakeLists.txt b/adcp/CMakeLists.txt new file mode 100644 index 000000000..84c1ab5ed --- /dev/null +++ b/adcp/CMakeLists.txt @@ -0,0 +1,174 @@ +# +# 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(adcp_public_header + include/alibabacloud/adcp/AdcpClient.h + include/alibabacloud/adcp/AdcpExport.h ) + +set(adcp_public_header_model + include/alibabacloud/adcp/model/AttachClusterToHubRequest.h + include/alibabacloud/adcp/model/AttachClusterToHubResult.h + include/alibabacloud/adcp/model/CreateHubClusterRequest.h + include/alibabacloud/adcp/model/CreateHubClusterResult.h + include/alibabacloud/adcp/model/DeleteHubClusterRequest.h + include/alibabacloud/adcp/model/DeleteHubClusterResult.h + include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.h + include/alibabacloud/adcp/model/DeletePolicyInstanceResult.h + include/alibabacloud/adcp/model/DeleteUserPermissionRequest.h + include/alibabacloud/adcp/model/DeleteUserPermissionResult.h + include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.h + include/alibabacloud/adcp/model/DeployPolicyInstanceResult.h + include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h + include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h + include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.h + include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.h + include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h + include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h + include/alibabacloud/adcp/model/DescribeHubClustersRequest.h + include/alibabacloud/adcp/model/DescribeHubClustersResult.h + include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h + include/alibabacloud/adcp/model/DescribeManagedClustersResult.h + include/alibabacloud/adcp/model/DescribePoliciesRequest.h + include/alibabacloud/adcp/model/DescribePoliciesResult.h + include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h + include/alibabacloud/adcp/model/DescribePolicyDetailsResult.h + include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h + include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h + include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.h + include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h + include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h + include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.h + include/alibabacloud/adcp/model/DescribeRegionsRequest.h + include/alibabacloud/adcp/model/DescribeRegionsResult.h + include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h + include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h + include/alibabacloud/adcp/model/DetachClusterFromHubRequest.h + include/alibabacloud/adcp/model/DetachClusterFromHubResult.h + include/alibabacloud/adcp/model/GrantUserPermissionRequest.h + include/alibabacloud/adcp/model/GrantUserPermissionResult.h + include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h + include/alibabacloud/adcp/model/GrantUserPermissionsResult.h + include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h + include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.h + include/alibabacloud/adcp/model/UpdateUserPermissionRequest.h + include/alibabacloud/adcp/model/UpdateUserPermissionResult.h ) + +set(adcp_src + src/AdcpClient.cc + src/model/AttachClusterToHubRequest.cc + src/model/AttachClusterToHubResult.cc + src/model/CreateHubClusterRequest.cc + src/model/CreateHubClusterResult.cc + src/model/DeleteHubClusterRequest.cc + src/model/DeleteHubClusterResult.cc + src/model/DeletePolicyInstanceRequest.cc + src/model/DeletePolicyInstanceResult.cc + src/model/DeleteUserPermissionRequest.cc + src/model/DeleteUserPermissionResult.cc + src/model/DeployPolicyInstanceRequest.cc + src/model/DeployPolicyInstanceResult.cc + src/model/DescribeHubClusterDetailsRequest.cc + src/model/DescribeHubClusterDetailsResult.cc + src/model/DescribeHubClusterKubeconfigRequest.cc + src/model/DescribeHubClusterKubeconfigResult.cc + src/model/DescribeHubClusterLogsRequest.cc + src/model/DescribeHubClusterLogsResult.cc + src/model/DescribeHubClustersRequest.cc + src/model/DescribeHubClustersResult.cc + src/model/DescribeManagedClustersRequest.cc + src/model/DescribeManagedClustersResult.cc + src/model/DescribePoliciesRequest.cc + src/model/DescribePoliciesResult.cc + src/model/DescribePolicyDetailsRequest.cc + src/model/DescribePolicyDetailsResult.cc + src/model/DescribePolicyGovernanceInClusterRequest.cc + src/model/DescribePolicyGovernanceInClusterResult.cc + src/model/DescribePolicyInstancesRequest.cc + src/model/DescribePolicyInstancesResult.cc + src/model/DescribePolicyInstancesStatusRequest.cc + src/model/DescribePolicyInstancesStatusResult.cc + src/model/DescribeRegionsRequest.cc + src/model/DescribeRegionsResult.cc + src/model/DescribeUserPermissionsRequest.cc + src/model/DescribeUserPermissionsResult.cc + src/model/DetachClusterFromHubRequest.cc + src/model/DetachClusterFromHubResult.cc + src/model/GrantUserPermissionRequest.cc + src/model/GrantUserPermissionResult.cc + src/model/GrantUserPermissionsRequest.cc + src/model/GrantUserPermissionsResult.cc + src/model/UpdateHubClusterFeatureRequest.cc + src/model/UpdateHubClusterFeatureResult.cc + src/model/UpdateUserPermissionRequest.cc + src/model/UpdateUserPermissionResult.cc ) + +add_library(adcp ${LIB_TYPE} + ${adcp_public_header} + ${adcp_public_header_model} + ${adcp_src}) + +set_target_properties(adcp + 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}adcp + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(adcp + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_ADCP_LIBRARY) +endif() + +target_include_directories(adcp + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(adcp + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(adcp + jsoncpp) + target_include_directories(adcp + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(adcp + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(adcp + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(adcp + PRIVATE /usr/include/jsoncpp) + target_link_libraries(adcp + jsoncpp) +endif() + +install(FILES ${adcp_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/adcp) +install(FILES ${adcp_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/adcp/model) +install(TARGETS adcp + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/AdcpClient.h b/adcp/include/alibabacloud/adcp/AdcpClient.h new file mode 100644 index 000000000..9bc0e7a36 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/AdcpClient.h @@ -0,0 +1,230 @@ +/* + * 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_ADCP_ADCPCLIENT_H_ +#define ALIBABACLOUD_ADCP_ADCPCLIENT_H_ + +#include +#include +#include +#include +#include "AdcpExport.h" +#include "model/AttachClusterToHubRequest.h" +#include "model/AttachClusterToHubResult.h" +#include "model/CreateHubClusterRequest.h" +#include "model/CreateHubClusterResult.h" +#include "model/DeleteHubClusterRequest.h" +#include "model/DeleteHubClusterResult.h" +#include "model/DeletePolicyInstanceRequest.h" +#include "model/DeletePolicyInstanceResult.h" +#include "model/DeleteUserPermissionRequest.h" +#include "model/DeleteUserPermissionResult.h" +#include "model/DeployPolicyInstanceRequest.h" +#include "model/DeployPolicyInstanceResult.h" +#include "model/DescribeHubClusterDetailsRequest.h" +#include "model/DescribeHubClusterDetailsResult.h" +#include "model/DescribeHubClusterKubeconfigRequest.h" +#include "model/DescribeHubClusterKubeconfigResult.h" +#include "model/DescribeHubClusterLogsRequest.h" +#include "model/DescribeHubClusterLogsResult.h" +#include "model/DescribeHubClustersRequest.h" +#include "model/DescribeHubClustersResult.h" +#include "model/DescribeManagedClustersRequest.h" +#include "model/DescribeManagedClustersResult.h" +#include "model/DescribePoliciesRequest.h" +#include "model/DescribePoliciesResult.h" +#include "model/DescribePolicyDetailsRequest.h" +#include "model/DescribePolicyDetailsResult.h" +#include "model/DescribePolicyGovernanceInClusterRequest.h" +#include "model/DescribePolicyGovernanceInClusterResult.h" +#include "model/DescribePolicyInstancesRequest.h" +#include "model/DescribePolicyInstancesResult.h" +#include "model/DescribePolicyInstancesStatusRequest.h" +#include "model/DescribePolicyInstancesStatusResult.h" +#include "model/DescribeRegionsRequest.h" +#include "model/DescribeRegionsResult.h" +#include "model/DescribeUserPermissionsRequest.h" +#include "model/DescribeUserPermissionsResult.h" +#include "model/DetachClusterFromHubRequest.h" +#include "model/DetachClusterFromHubResult.h" +#include "model/GrantUserPermissionRequest.h" +#include "model/GrantUserPermissionResult.h" +#include "model/GrantUserPermissionsRequest.h" +#include "model/GrantUserPermissionsResult.h" +#include "model/UpdateHubClusterFeatureRequest.h" +#include "model/UpdateHubClusterFeatureResult.h" +#include "model/UpdateUserPermissionRequest.h" +#include "model/UpdateUserPermissionResult.h" + + +namespace AlibabaCloud +{ + namespace Adcp + { + class ALIBABACLOUD_ADCP_EXPORT AdcpClient : public RpcServiceClient + { + public: + typedef Outcome AttachClusterToHubOutcome; + typedef std::future AttachClusterToHubOutcomeCallable; + typedef std::function&)> AttachClusterToHubAsyncHandler; + typedef Outcome CreateHubClusterOutcome; + typedef std::future CreateHubClusterOutcomeCallable; + typedef std::function&)> CreateHubClusterAsyncHandler; + typedef Outcome DeleteHubClusterOutcome; + typedef std::future DeleteHubClusterOutcomeCallable; + typedef std::function&)> DeleteHubClusterAsyncHandler; + typedef Outcome DeletePolicyInstanceOutcome; + typedef std::future DeletePolicyInstanceOutcomeCallable; + typedef std::function&)> DeletePolicyInstanceAsyncHandler; + typedef Outcome DeleteUserPermissionOutcome; + typedef std::future DeleteUserPermissionOutcomeCallable; + typedef std::function&)> DeleteUserPermissionAsyncHandler; + typedef Outcome DeployPolicyInstanceOutcome; + typedef std::future DeployPolicyInstanceOutcomeCallable; + typedef std::function&)> DeployPolicyInstanceAsyncHandler; + typedef Outcome DescribeHubClusterDetailsOutcome; + typedef std::future DescribeHubClusterDetailsOutcomeCallable; + typedef std::function&)> DescribeHubClusterDetailsAsyncHandler; + typedef Outcome DescribeHubClusterKubeconfigOutcome; + typedef std::future DescribeHubClusterKubeconfigOutcomeCallable; + typedef std::function&)> DescribeHubClusterKubeconfigAsyncHandler; + typedef Outcome DescribeHubClusterLogsOutcome; + typedef std::future DescribeHubClusterLogsOutcomeCallable; + typedef std::function&)> DescribeHubClusterLogsAsyncHandler; + typedef Outcome DescribeHubClustersOutcome; + typedef std::future DescribeHubClustersOutcomeCallable; + typedef std::function&)> DescribeHubClustersAsyncHandler; + typedef Outcome DescribeManagedClustersOutcome; + typedef std::future DescribeManagedClustersOutcomeCallable; + typedef std::function&)> DescribeManagedClustersAsyncHandler; + typedef Outcome DescribePoliciesOutcome; + typedef std::future DescribePoliciesOutcomeCallable; + typedef std::function&)> DescribePoliciesAsyncHandler; + typedef Outcome DescribePolicyDetailsOutcome; + typedef std::future DescribePolicyDetailsOutcomeCallable; + typedef std::function&)> DescribePolicyDetailsAsyncHandler; + typedef Outcome DescribePolicyGovernanceInClusterOutcome; + typedef std::future DescribePolicyGovernanceInClusterOutcomeCallable; + typedef std::function&)> DescribePolicyGovernanceInClusterAsyncHandler; + typedef Outcome DescribePolicyInstancesOutcome; + typedef std::future DescribePolicyInstancesOutcomeCallable; + typedef std::function&)> DescribePolicyInstancesAsyncHandler; + typedef Outcome DescribePolicyInstancesStatusOutcome; + typedef std::future DescribePolicyInstancesStatusOutcomeCallable; + typedef std::function&)> DescribePolicyInstancesStatusAsyncHandler; + typedef Outcome DescribeRegionsOutcome; + typedef std::future DescribeRegionsOutcomeCallable; + typedef std::function&)> DescribeRegionsAsyncHandler; + typedef Outcome DescribeUserPermissionsOutcome; + typedef std::future DescribeUserPermissionsOutcomeCallable; + typedef std::function&)> DescribeUserPermissionsAsyncHandler; + typedef Outcome DetachClusterFromHubOutcome; + typedef std::future DetachClusterFromHubOutcomeCallable; + typedef std::function&)> DetachClusterFromHubAsyncHandler; + typedef Outcome GrantUserPermissionOutcome; + typedef std::future GrantUserPermissionOutcomeCallable; + typedef std::function&)> GrantUserPermissionAsyncHandler; + typedef Outcome GrantUserPermissionsOutcome; + typedef std::future GrantUserPermissionsOutcomeCallable; + typedef std::function&)> GrantUserPermissionsAsyncHandler; + typedef Outcome UpdateHubClusterFeatureOutcome; + typedef std::future UpdateHubClusterFeatureOutcomeCallable; + typedef std::function&)> UpdateHubClusterFeatureAsyncHandler; + typedef Outcome UpdateUserPermissionOutcome; + typedef std::future UpdateUserPermissionOutcomeCallable; + typedef std::function&)> UpdateUserPermissionAsyncHandler; + + AdcpClient(const Credentials &credentials, const ClientConfiguration &configuration); + AdcpClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + AdcpClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~AdcpClient(); + AttachClusterToHubOutcome attachClusterToHub(const Model::AttachClusterToHubRequest &request)const; + void attachClusterToHubAsync(const Model::AttachClusterToHubRequest& request, const AttachClusterToHubAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AttachClusterToHubOutcomeCallable attachClusterToHubCallable(const Model::AttachClusterToHubRequest& request) const; + CreateHubClusterOutcome createHubCluster(const Model::CreateHubClusterRequest &request)const; + void createHubClusterAsync(const Model::CreateHubClusterRequest& request, const CreateHubClusterAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateHubClusterOutcomeCallable createHubClusterCallable(const Model::CreateHubClusterRequest& request) const; + DeleteHubClusterOutcome deleteHubCluster(const Model::DeleteHubClusterRequest &request)const; + void deleteHubClusterAsync(const Model::DeleteHubClusterRequest& request, const DeleteHubClusterAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteHubClusterOutcomeCallable deleteHubClusterCallable(const Model::DeleteHubClusterRequest& request) const; + DeletePolicyInstanceOutcome deletePolicyInstance(const Model::DeletePolicyInstanceRequest &request)const; + void deletePolicyInstanceAsync(const Model::DeletePolicyInstanceRequest& request, const DeletePolicyInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeletePolicyInstanceOutcomeCallable deletePolicyInstanceCallable(const Model::DeletePolicyInstanceRequest& request) const; + DeleteUserPermissionOutcome deleteUserPermission(const Model::DeleteUserPermissionRequest &request)const; + void deleteUserPermissionAsync(const Model::DeleteUserPermissionRequest& request, const DeleteUserPermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteUserPermissionOutcomeCallable deleteUserPermissionCallable(const Model::DeleteUserPermissionRequest& request) const; + DeployPolicyInstanceOutcome deployPolicyInstance(const Model::DeployPolicyInstanceRequest &request)const; + void deployPolicyInstanceAsync(const Model::DeployPolicyInstanceRequest& request, const DeployPolicyInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeployPolicyInstanceOutcomeCallable deployPolicyInstanceCallable(const Model::DeployPolicyInstanceRequest& request) const; + DescribeHubClusterDetailsOutcome describeHubClusterDetails(const Model::DescribeHubClusterDetailsRequest &request)const; + void describeHubClusterDetailsAsync(const Model::DescribeHubClusterDetailsRequest& request, const DescribeHubClusterDetailsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeHubClusterDetailsOutcomeCallable describeHubClusterDetailsCallable(const Model::DescribeHubClusterDetailsRequest& request) const; + DescribeHubClusterKubeconfigOutcome describeHubClusterKubeconfig(const Model::DescribeHubClusterKubeconfigRequest &request)const; + void describeHubClusterKubeconfigAsync(const Model::DescribeHubClusterKubeconfigRequest& request, const DescribeHubClusterKubeconfigAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeHubClusterKubeconfigOutcomeCallable describeHubClusterKubeconfigCallable(const Model::DescribeHubClusterKubeconfigRequest& request) const; + DescribeHubClusterLogsOutcome describeHubClusterLogs(const Model::DescribeHubClusterLogsRequest &request)const; + void describeHubClusterLogsAsync(const Model::DescribeHubClusterLogsRequest& request, const DescribeHubClusterLogsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeHubClusterLogsOutcomeCallable describeHubClusterLogsCallable(const Model::DescribeHubClusterLogsRequest& request) const; + DescribeHubClustersOutcome describeHubClusters(const Model::DescribeHubClustersRequest &request)const; + void describeHubClustersAsync(const Model::DescribeHubClustersRequest& request, const DescribeHubClustersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeHubClustersOutcomeCallable describeHubClustersCallable(const Model::DescribeHubClustersRequest& request) const; + DescribeManagedClustersOutcome describeManagedClusters(const Model::DescribeManagedClustersRequest &request)const; + void describeManagedClustersAsync(const Model::DescribeManagedClustersRequest& request, const DescribeManagedClustersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeManagedClustersOutcomeCallable describeManagedClustersCallable(const Model::DescribeManagedClustersRequest& request) const; + DescribePoliciesOutcome describePolicies(const Model::DescribePoliciesRequest &request)const; + void describePoliciesAsync(const Model::DescribePoliciesRequest& request, const DescribePoliciesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribePoliciesOutcomeCallable describePoliciesCallable(const Model::DescribePoliciesRequest& request) const; + DescribePolicyDetailsOutcome describePolicyDetails(const Model::DescribePolicyDetailsRequest &request)const; + void describePolicyDetailsAsync(const Model::DescribePolicyDetailsRequest& request, const DescribePolicyDetailsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribePolicyDetailsOutcomeCallable describePolicyDetailsCallable(const Model::DescribePolicyDetailsRequest& request) const; + DescribePolicyGovernanceInClusterOutcome describePolicyGovernanceInCluster(const Model::DescribePolicyGovernanceInClusterRequest &request)const; + void describePolicyGovernanceInClusterAsync(const Model::DescribePolicyGovernanceInClusterRequest& request, const DescribePolicyGovernanceInClusterAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribePolicyGovernanceInClusterOutcomeCallable describePolicyGovernanceInClusterCallable(const Model::DescribePolicyGovernanceInClusterRequest& request) const; + DescribePolicyInstancesOutcome describePolicyInstances(const Model::DescribePolicyInstancesRequest &request)const; + void describePolicyInstancesAsync(const Model::DescribePolicyInstancesRequest& request, const DescribePolicyInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribePolicyInstancesOutcomeCallable describePolicyInstancesCallable(const Model::DescribePolicyInstancesRequest& request) const; + DescribePolicyInstancesStatusOutcome describePolicyInstancesStatus(const Model::DescribePolicyInstancesStatusRequest &request)const; + void describePolicyInstancesStatusAsync(const Model::DescribePolicyInstancesStatusRequest& request, const DescribePolicyInstancesStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribePolicyInstancesStatusOutcomeCallable describePolicyInstancesStatusCallable(const Model::DescribePolicyInstancesStatusRequest& 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; + DescribeUserPermissionsOutcome describeUserPermissions(const Model::DescribeUserPermissionsRequest &request)const; + void describeUserPermissionsAsync(const Model::DescribeUserPermissionsRequest& request, const DescribeUserPermissionsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeUserPermissionsOutcomeCallable describeUserPermissionsCallable(const Model::DescribeUserPermissionsRequest& request) const; + DetachClusterFromHubOutcome detachClusterFromHub(const Model::DetachClusterFromHubRequest &request)const; + void detachClusterFromHubAsync(const Model::DetachClusterFromHubRequest& request, const DetachClusterFromHubAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DetachClusterFromHubOutcomeCallable detachClusterFromHubCallable(const Model::DetachClusterFromHubRequest& request) const; + GrantUserPermissionOutcome grantUserPermission(const Model::GrantUserPermissionRequest &request)const; + void grantUserPermissionAsync(const Model::GrantUserPermissionRequest& request, const GrantUserPermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GrantUserPermissionOutcomeCallable grantUserPermissionCallable(const Model::GrantUserPermissionRequest& request) const; + GrantUserPermissionsOutcome grantUserPermissions(const Model::GrantUserPermissionsRequest &request)const; + void grantUserPermissionsAsync(const Model::GrantUserPermissionsRequest& request, const GrantUserPermissionsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GrantUserPermissionsOutcomeCallable grantUserPermissionsCallable(const Model::GrantUserPermissionsRequest& request) const; + UpdateHubClusterFeatureOutcome updateHubClusterFeature(const Model::UpdateHubClusterFeatureRequest &request)const; + void updateHubClusterFeatureAsync(const Model::UpdateHubClusterFeatureRequest& request, const UpdateHubClusterFeatureAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateHubClusterFeatureOutcomeCallable updateHubClusterFeatureCallable(const Model::UpdateHubClusterFeatureRequest& request) const; + UpdateUserPermissionOutcome updateUserPermission(const Model::UpdateUserPermissionRequest &request)const; + void updateUserPermissionAsync(const Model::UpdateUserPermissionRequest& request, const UpdateUserPermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateUserPermissionOutcomeCallable updateUserPermissionCallable(const Model::UpdateUserPermissionRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_ADCP_ADCPCLIENT_H_ diff --git a/adcp/include/alibabacloud/adcp/AdcpExport.h b/adcp/include/alibabacloud/adcp/AdcpExport.h new file mode 100644 index 000000000..50f8c4f03 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/AdcpExport.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_ADCP_ADCPEXPORT_H_ +#define ALIBABACLOUD_ADCP_ADCPEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_ADCP_LIBRARY) +# define ALIBABACLOUD_ADCP_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_ADCP_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_ADCP_EXPORT +#endif + +#endif // !ALIBABACLOUD_ADCP_ADCPEXPORT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/AttachClusterToHubRequest.h b/adcp/include/alibabacloud/adcp/model/AttachClusterToHubRequest.h new file mode 100644 index 000000000..5ac25719a --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/AttachClusterToHubRequest.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_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT AttachClusterToHubRequest : public RpcServiceRequest { +public: + AttachClusterToHubRequest(); + ~AttachClusterToHubRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string getClusterIds() const; + void setClusterIds(const std::string &clusterIds); + bool getAttachToMesh() const; + void setAttachToMesh(bool attachToMesh); + +private: + std::string clusterId_; + std::string clusterIds_; + bool attachToMesh_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/AttachClusterToHubResult.h b/adcp/include/alibabacloud/adcp/model/AttachClusterToHubResult.h new file mode 100644 index 000000000..e6b72aed8 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/AttachClusterToHubResult.h @@ -0,0 +1,55 @@ +/* + * 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_ADCP_MODEL_ATTACHCLUSTERTOHUBRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT AttachClusterToHubResult : public ServiceResult + { + public: + + + AttachClusterToHubResult(); + explicit AttachClusterToHubResult(const std::string &payload); + ~AttachClusterToHubResult(); + std::string getTaskId()const; + std::string getClusterId()const; + std::vector getManagedClusterIds()const; + + protected: + void parse(const std::string &payload); + private: + std::string taskId_; + std::string clusterId_; + std::vector managedClusterIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/CreateHubClusterRequest.h b/adcp/include/alibabacloud/adcp/model/CreateHubClusterRequest.h new file mode 100644 index 000000000..d22571ce6 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/CreateHubClusterRequest.h @@ -0,0 +1,121 @@ +/* + * 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_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT CreateHubClusterRequest : public RpcServiceRequest { +public: + struct WorkflowUnits { + std::string regionId; + std::string vpcId; + struct VSwitchesItem { + std::string vswitchId; + std::string zoneId; + }; + VSwitchesItem vSwitchesItem; + std::vector vSwitches; + }; + CreateHubClusterRequest(); + ~CreateHubClusterRequest(); + std::string getAuditLogProject() const; + void setAuditLogProject(const std::string &auditLogProject); + std::string getLoadBalancerSpec() const; + void setLoadBalancerSpec(const std::string &loadBalancerSpec); + std::string getKubernetesVersion() const; + void setKubernetesVersion(const std::string &kubernetesVersion); + std::string getProfile() const; + void setProfile(const std::string &profile); + std::string getVSwitches() const; + void setVSwitches(const std::string &vSwitches); + std::string getControlPlaneLogProject() const; + void setControlPlaneLogProject(const std::string &controlPlaneLogProject); + std::string getLoadBalancerId() const; + void setLoadBalancerId(const std::string &loadBalancerId); + std::string getClusterSpec() const; + void setClusterSpec(const std::string &clusterSpec); + std::string getName() const; + void setName(const std::string &name); + std::string getClusterDomain() const; + void setClusterDomain(const std::string &clusterDomain); + std::string getControlPlaneLogTTL() const; + void setControlPlaneLogTTL(const std::string &controlPlaneLogTTL); + std::vector getWorkflowUnits() const; + void setWorkflowUnits(const std::vector &workflowUnits); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getAuditLogStoreTTL() const; + void setAuditLogStoreTTL(const std::string &auditLogStoreTTL); + std::string getIPStack() const; + void setIPStack(const std::string &iPStack); + bool getControlPlaneLogEnabled() const; + void setControlPlaneLogEnabled(bool controlPlaneLogEnabled); + bool getArgoServerEnabled() const; + void setArgoServerEnabled(bool argoServerEnabled); + std::string getWorkflowScheduleMode() const; + void setWorkflowScheduleMode(const std::string &workflowScheduleMode); + bool getApiServerPublicEip() const; + void setApiServerPublicEip(bool apiServerPublicEip); + bool getAuditLogEnabled() const; + void setAuditLogEnabled(bool auditLogEnabled); + std::string getSecurityGroupIDs() const; + void setSecurityGroupIDs(const std::string &securityGroupIDs); + std::string getPriceLimit() const; + void setPriceLimit(const std::string &priceLimit); + bool getIsEnterpriseSecurityGroup() const; + void setIsEnterpriseSecurityGroup(bool isEnterpriseSecurityGroup); + std::string getVpcId() const; + void setVpcId(const std::string &vpcId); + +private: + std::string auditLogProject_; + std::string loadBalancerSpec_; + std::string kubernetesVersion_; + std::string profile_; + std::string vSwitches_; + std::string controlPlaneLogProject_; + std::string loadBalancerId_; + std::string clusterSpec_; + std::string name_; + std::string clusterDomain_; + std::string controlPlaneLogTTL_; + std::vector workflowUnits_; + std::string regionId_; + std::string auditLogStoreTTL_; + std::string iPStack_; + bool controlPlaneLogEnabled_; + bool argoServerEnabled_; + std::string workflowScheduleMode_; + bool apiServerPublicEip_; + bool auditLogEnabled_; + std::string securityGroupIDs_; + std::string priceLimit_; + bool isEnterpriseSecurityGroup_; + std::string vpcId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/CreateHubClusterResult.h b/adcp/include/alibabacloud/adcp/model/CreateHubClusterResult.h new file mode 100644 index 000000000..b13b5d26d --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/CreateHubClusterResult.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_ADCP_MODEL_CREATEHUBCLUSTERRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT CreateHubClusterResult : public ServiceResult + { + public: + + + CreateHubClusterResult(); + explicit CreateHubClusterResult(const std::string &payload); + ~CreateHubClusterResult(); + std::string getTaskId()const; + std::string getClusterId()const; + + protected: + void parse(const std::string &payload); + private: + std::string taskId_; + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DeleteHubClusterRequest.h b/adcp/include/alibabacloud/adcp/model/DeleteHubClusterRequest.h new file mode 100644 index 000000000..d56a140ae --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeleteHubClusterRequest.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_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DeleteHubClusterRequest : public RpcServiceRequest { +public: + DeleteHubClusterRequest(); + ~DeleteHubClusterRequest(); + std::vector getRetainResources() const; + void setRetainResources(const std::vector &retainResources); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + bool getForce() const; + void setForce(bool force); + +private: + std::vector retainResources_; + std::string clusterId_; + bool force_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DeleteHubClusterResult.h b/adcp/include/alibabacloud/adcp/model/DeleteHubClusterResult.h new file mode 100644 index 000000000..8055a38d9 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeleteHubClusterResult.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_ADCP_MODEL_DELETEHUBCLUSTERRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DeleteHubClusterResult : public ServiceResult + { + public: + + + DeleteHubClusterResult(); + explicit DeleteHubClusterResult(const std::string &payload); + ~DeleteHubClusterResult(); + std::string getTaskId()const; + std::string getClusterId()const; + + protected: + void parse(const std::string &payload); + private: + std::string taskId_; + std::string clusterId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.h b/adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.h new file mode 100644 index 000000000..60bb0c532 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.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_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DeletePolicyInstanceRequest : public RpcServiceRequest { +public: + DeletePolicyInstanceRequest(); + ~DeletePolicyInstanceRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::vector getClusterIds() const; + void setClusterIds(const std::vector &clusterIds); + std::string getPolicyName() const; + void setPolicyName(const std::string &policyName); + +private: + std::string clusterId_; + std::vector clusterIds_; + std::string policyName_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceResult.h b/adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceResult.h new file mode 100644 index 000000000..6a5571afd --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceResult.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_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DeletePolicyInstanceResult : public ServiceResult + { + public: + + + DeletePolicyInstanceResult(); + explicit DeletePolicyInstanceResult(const std::string &payload); + ~DeletePolicyInstanceResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DeleteUserPermissionRequest.h b/adcp/include/alibabacloud/adcp/model/DeleteUserPermissionRequest.h new file mode 100644 index 000000000..2f53e0551 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeleteUserPermissionRequest.h @@ -0,0 +1,45 @@ +/* + * 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_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DeleteUserPermissionRequest : public RpcServiceRequest { +public: + DeleteUserPermissionRequest(); + ~DeleteUserPermissionRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + +private: + std::string userId_; + std::string clusterId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DeleteUserPermissionResult.h b/adcp/include/alibabacloud/adcp/model/DeleteUserPermissionResult.h new file mode 100644 index 000000000..3ea092478 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeleteUserPermissionResult.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_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DeleteUserPermissionResult : public ServiceResult + { + public: + + + DeleteUserPermissionResult(); + explicit DeleteUserPermissionResult(const std::string &payload); + ~DeleteUserPermissionResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.h b/adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.h new file mode 100644 index 000000000..b8add79f0 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.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_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DeployPolicyInstanceRequest : public RpcServiceRequest { +public: + DeployPolicyInstanceRequest(); + ~DeployPolicyInstanceRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string getPolicyAction() const; + void setPolicyAction(const std::string &policyAction); + std::vector getClusterIds() const; + void setClusterIds(const std::vector &clusterIds); + std::string getPolicyName() const; + void setPolicyName(const std::string &policyName); + std::vector getNamespaces() const; + void setNamespaces(const std::vector &namespaces); + +private: + std::string clusterId_; + std::string policyAction_; + std::vector clusterIds_; + std::string policyName_; + std::vector namespaces_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceResult.h b/adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceResult.h new file mode 100644 index 000000000..859550ec7 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceResult.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_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DeployPolicyInstanceResult : public ServiceResult + { + public: + + + DeployPolicyInstanceResult(); + explicit DeployPolicyInstanceResult(const std::string &payload); + ~DeployPolicyInstanceResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h new file mode 100644 index 000000000..371683ddf --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterDetailsRequest : public RpcServiceRequest { +public: + DescribeHubClusterDetailsRequest(); + ~DescribeHubClusterDetailsRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + +private: + std::string clusterId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h new file mode 100644 index 000000000..cffcf5472 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h @@ -0,0 +1,130 @@ +/* + * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterDetailsResult : public ServiceResult + { + public: + struct Cluster + { + struct Endpoints + { + std::string intranetApiServerEndpoint; + std::string publicApiServerEndpoint; + }; + struct ClusterInfo + { + std::string version; + std::string clusterId; + std::string state; + std::string creationTime; + std::string updateTime; + std::string regionId; + std::string clusterSpec; + std::string errorMessage; + std::string profile; + std::string name; + }; + struct Network + { + std::string iPStack; + std::string vpcId; + std::string clusterDomain; + std::vector vSwitches; + std::vector securityGroupIDs; + }; + struct ApiServer + { + std::string apiServerEipId; + bool enabledPublic; + std::string loadBalancerId; + }; + struct MeshConfig + { + std::string meshId; + bool enableMesh; + }; + struct LogConfig + { + std::string logStoreTTL; + bool enableLog; + std::string logProject; + }; + struct WorkflowConfig + { + struct WorkflowUnit + { + struct VSwitch + { + std::string zoneId; + std::string vswitchId; + }; + std::string vpcId; + std::vector vSwitches1; + std::string regionId; + }; + std::vector workflowUnits; + std::string priceLimit; + bool argoServerEnabled; + std::string workflowScheduleMode; + }; + struct Condition + { + std::string status; + std::string type; + std::string message; + std::string reason; + }; + Endpoints endpoints; + WorkflowConfig workflowConfig; + ClusterInfo clusterInfo; + ApiServer apiServer; + MeshConfig meshConfig; + Network network; + std::vector conditions; + LogConfig logConfig; + }; + + + DescribeHubClusterDetailsResult(); + explicit DescribeHubClusterDetailsResult(const std::string &payload); + ~DescribeHubClusterDetailsResult(); + Cluster getCluster()const; + + protected: + void parse(const std::string &payload); + private: + Cluster cluster_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.h new file mode 100644 index 000000000..0e39813dc --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.h @@ -0,0 +1,45 @@ +/* + * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterKubeconfigRequest : public RpcServiceRequest { +public: + DescribeHubClusterKubeconfigRequest(); + ~DescribeHubClusterKubeconfigRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + bool getPrivateIpAddress() const; + void setPrivateIpAddress(bool privateIpAddress); + +private: + std::string clusterId_; + bool privateIpAddress_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.h new file mode 100644 index 000000000..b489df4d3 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.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_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterKubeconfigResult : public ServiceResult + { + public: + + + DescribeHubClusterKubeconfigResult(); + explicit DescribeHubClusterKubeconfigResult(const std::string &payload); + ~DescribeHubClusterKubeconfigResult(); + std::string getKubeconfig()const; + + protected: + void parse(const std::string &payload); + private: + std::string kubeconfig_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h new file mode 100644 index 000000000..75da369cf --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterLogsRequest : public RpcServiceRequest { +public: + DescribeHubClusterLogsRequest(); + ~DescribeHubClusterLogsRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + +private: + std::string clusterId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h new file mode 100644 index 000000000..54d32e40d --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterLogsResult : public ServiceResult + { + public: + struct Log + { + std::string clusterId; + std::string creationTime; + std::string clusterLog; + std::string logLevel; + }; + + + DescribeHubClusterLogsResult(); + explicit DescribeHubClusterLogsResult(const std::string &payload); + ~DescribeHubClusterLogsResult(); + std::vector getLogs()const; + + protected: + void parse(const std::string &payload); + private: + std::vector logs_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClustersRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClustersRequest.h new file mode 100644 index 000000000..cc16921ed --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClustersRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeHubClustersRequest : public RpcServiceRequest { +public: + DescribeHubClustersRequest(); + ~DescribeHubClustersRequest(); + std::string getProfile() const; + void setProfile(const std::string &profile); + +private: + std::string profile_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeHubClustersResult.h b/adcp/include/alibabacloud/adcp/model/DescribeHubClustersResult.h new file mode 100644 index 000000000..059d682b2 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeHubClustersResult.h @@ -0,0 +1,110 @@ +/* + * 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_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeHubClustersResult : public ServiceResult + { + public: + struct Cluster + { + struct Endpoints + { + std::string intranetApiServerEndpoint; + std::string publicApiServerEndpoint; + }; + struct ClusterInfo + { + std::string version; + std::string clusterId; + std::string state; + std::string creationTime; + std::string updateTime; + std::string regionId; + std::string clusterSpec; + std::string errorMessage; + std::string profile; + std::string name; + }; + struct Network + { + std::string vpcId; + std::string clusterDomain; + std::vector vSwitches; + std::vector securityGroupIDs; + }; + struct ApiServer + { + std::string apiServerEipId; + bool enabledPublic; + std::string loadBalancerId; + }; + struct MeshConfig + { + std::string meshId; + bool enableMesh; + }; + struct LogConfig + { + std::string logStoreTTL; + bool enableLog; + std::string logProject; + }; + struct Condition + { + std::string status; + std::string type; + std::string message; + std::string reason; + }; + Endpoints endpoints; + ClusterInfo clusterInfo; + ApiServer apiServer; + MeshConfig meshConfig; + Network network; + std::vector conditions; + LogConfig logConfig; + }; + + + DescribeHubClustersResult(); + explicit DescribeHubClustersResult(const std::string &payload); + ~DescribeHubClustersResult(); + std::vector getClusters()const; + + protected: + void parse(const std::string &payload); + private: + std::vector clusters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h new file mode 100644 index 000000000..d5d075554 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeManagedClustersRequest : public RpcServiceRequest { +public: + DescribeManagedClustersRequest(); + ~DescribeManagedClustersRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + +private: + std::string clusterId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeManagedClustersResult.h b/adcp/include/alibabacloud/adcp/model/DescribeManagedClustersResult.h new file mode 100644 index 000000000..2d3ba2123 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeManagedClustersResult.h @@ -0,0 +1,83 @@ +/* + * 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_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeManagedClustersResult : public ServiceResult + { + public: + struct Cluster + { + struct Cluster1 + { + std::string updated; + std::string resourceGroupId; + std::string clusterID; + std::string initVersion; + std::string currentVersion; + std::string vSwitchID; + std::string clusterType; + std::string clusterSpec; + std::string profile; + std::string name; + std::string created; + std::string vpcID; + std::string state; + std::string region; + }; + struct Status + { + std::string message; + std::string state; + }; + struct MeshStatus + { + bool inMesh; + }; + Status status; + Cluster1 cluster1; + MeshStatus meshStatus; + }; + + + DescribeManagedClustersResult(); + explicit DescribeManagedClustersResult(const std::string &payload); + ~DescribeManagedClustersResult(); + std::vector getClusters()const; + + protected: + void parse(const std::string &payload); + private: + std::vector clusters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribePoliciesRequest.h b/adcp/include/alibabacloud/adcp/model/DescribePoliciesRequest.h new file mode 100644 index 000000000..9292c49dd --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePoliciesRequest.h @@ -0,0 +1,39 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribePoliciesRequest : public RpcServiceRequest { +public: + DescribePoliciesRequest(); + ~DescribePoliciesRequest(); + +private: +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribePoliciesResult.h b/adcp/include/alibabacloud/adcp/model/DescribePoliciesResult.h new file mode 100644 index 000000000..43d2c8ab1 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePoliciesResult.h @@ -0,0 +1,56 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICIESRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribePoliciesResult : public ServiceResult + { + public: + struct Policy + { + std::vector names; + std::string category; + }; + + + DescribePoliciesResult(); + explicit DescribePoliciesResult(const std::string &payload); + ~DescribePoliciesResult(); + std::vector getPolicies()const; + + protected: + void parse(const std::string &payload); + private: + std::vector policies_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h new file mode 100644 index 000000000..d464a570e --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribePolicyDetailsRequest : public RpcServiceRequest { +public: + DescribePolicyDetailsRequest(); + ~DescribePolicyDetailsRequest(); + std::string getPolicyName() const; + void setPolicyName(const std::string &policyName); + +private: + std::string policyName_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsResult.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsResult.h new file mode 100644 index 000000000..de8ceb773 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsResult.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_ADCP_MODEL_DESCRIBEPOLICYDETAILSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribePolicyDetailsResult : public ServiceResult + { + public: + struct Policy + { + int noConfig; + std::string action; + std::string category; + std::string description; + std::string _template; + std::string updated; + std::string severity; + std::string name; + std::string created; + }; + + + DescribePolicyDetailsResult(); + explicit DescribePolicyDetailsResult(const std::string &payload); + ~DescribePolicyDetailsResult(); + Policy getPolicy()const; + + protected: + void parse(const std::string &payload); + private: + Policy policy_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h new file mode 100644 index 000000000..f24b96396 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribePolicyGovernanceInClusterRequest : public RpcServiceRequest { +public: + DescribePolicyGovernanceInClusterRequest(); + ~DescribePolicyGovernanceInClusterRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + +private: + std::string clusterId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h new file mode 100644 index 000000000..336e7f6f9 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h @@ -0,0 +1,125 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribePolicyGovernanceInClusterResult : public ServiceResult + { + public: + struct PolicyGovernance + { + struct Cluster + { + std::string clusterId; + std::string state; + std::string regionId; + std::string clusterType; + std::string clusterSpec; + std::string profile; + std::string name; + }; + struct PolicyGovernance1 + { + struct AdmitLog + { + std::string progress; + std::string logStore; + std::string count; + std::vector logs; + std::string logProject; + }; + struct Violation + { + struct TotalViolations + { + struct DenySeverity + { + long violations; + std::string severity; + }; + struct WarnSeverity + { + std::string violations; + std::string severity; + }; + std::vector deny; + std::vector warn; + }; + struct Violations + { + struct DenyViolations + { + std::string policyDescription; + long violations; + std::string policyName; + std::string severity; + }; + struct WarnViolations + { + std::string policyDescription; + long violations; + std::string policyName; + std::string severity; + }; + std::vector warn3; + std::vector deny2; + }; + Violations violations; + TotalViolations totalViolations; + }; + struct State + { + long totalCount; + long enabledCount; + std::string severity; + }; + Violation violation; + AdmitLog admitLog; + std::vector onState; + }; + PolicyGovernance1 policyGovernance1; + Cluster cluster; + }; + + + DescribePolicyGovernanceInClusterResult(); + explicit DescribePolicyGovernanceInClusterResult(const std::string &payload); + ~DescribePolicyGovernanceInClusterResult(); + std::vector getPolicyGovernances()const; + + protected: + void parse(const std::string &payload); + private: + std::vector policyGovernances_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.h new file mode 100644 index 000000000..758ea89bf --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.h @@ -0,0 +1,45 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesRequest : public RpcServiceRequest { +public: + DescribePolicyInstancesRequest(); + ~DescribePolicyInstancesRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string getPolicyName() const; + void setPolicyName(const std::string &policyName); + +private: + std::string clusterId_; + std::string policyName_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h new file mode 100644 index 000000000..7af6e02d7 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h @@ -0,0 +1,64 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesResult : public ServiceResult + { + public: + struct Policy + { + std::string instanceName; + std::string policyParameters; + std::string policyDescription; + std::string clusterId; + std::string policyName; + std::string policyCategory; + std::string policySeverity; + long totalViolations; + std::string policyAction; + std::string policyScope; + }; + + + DescribePolicyInstancesResult(); + explicit DescribePolicyInstancesResult(const std::string &payload); + ~DescribePolicyInstancesResult(); + std::vector getPolicies()const; + + protected: + void parse(const std::string &payload); + private: + std::vector policies_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h new file mode 100644 index 000000000..db6c2042f --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesStatusRequest : public RpcServiceRequest { +public: + DescribePolicyInstancesStatusRequest(); + ~DescribePolicyInstancesStatusRequest(); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + +private: + std::string clusterId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.h b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.h new file mode 100644 index 000000000..83e68d737 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.h @@ -0,0 +1,75 @@ +/* + * 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesStatusResult : public ServiceResult + { + public: + struct Policies + { + struct PolicyInstance + { + struct PolicyCluster + { + std::string status; + std::string clusterId; + }; + std::string policyDescription; + std::vector policyClusters; + std::string policyName; + std::string policyCategory; + long policyInstancesCount; + std::string policySeverity; + }; + struct SeverityInfoItem + { + std::string severityType; + std::string severityCount; + }; + std::vector severityInfo; + std::vector policyInstances; + }; + + + DescribePolicyInstancesStatusResult(); + explicit DescribePolicyInstancesStatusResult(const std::string &payload); + ~DescribePolicyInstancesStatusResult(); + Policies getPolicies()const; + + protected: + void parse(const std::string &payload); + private: + Policies policies_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeRegionsRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeRegionsRequest.h new file mode 100644 index 000000000..ed84bb7bc --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeRegionsRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeRegionsRequest : public RpcServiceRequest { +public: + DescribeRegionsRequest(); + ~DescribeRegionsRequest(); + std::string getLanguage() const; + void setLanguage(const std::string &language); + +private: + std::string language_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeRegionsResult.h b/adcp/include/alibabacloud/adcp/model/DescribeRegionsResult.h new file mode 100644 index 000000000..46431bd89 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeRegionsResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeRegionsResult : public ServiceResult + { + public: + struct Region + { + std::string regionId; + std::string regionEndpoint; + std::string regionVpcEndpoint; + 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_ADCP_MODEL_DESCRIBEREGIONSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h b/adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h new file mode 100644 index 000000000..e8c6a1559 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h @@ -0,0 +1,42 @@ +/* + * 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_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DescribeUserPermissionsRequest : public RpcServiceRequest { +public: + DescribeUserPermissionsRequest(); + ~DescribeUserPermissionsRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + +private: + std::string userId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h b/adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h new file mode 100644 index 000000000..409b26e93 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DescribeUserPermissionsResult : public ServiceResult + { + public: + struct Permission + { + std::string roleName; + std::string resourceId; + std::string roleType; + std::string resourceType; + }; + + + DescribeUserPermissionsResult(); + explicit DescribeUserPermissionsResult(const std::string &payload); + ~DescribeUserPermissionsResult(); + std::vector getPermissions()const; + + protected: + void parse(const std::string &payload); + private: + std::vector permissions_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/DetachClusterFromHubRequest.h b/adcp/include/alibabacloud/adcp/model/DetachClusterFromHubRequest.h new file mode 100644 index 000000000..eca1c9abb --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DetachClusterFromHubRequest.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_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT DetachClusterFromHubRequest : public RpcServiceRequest { +public: + DetachClusterFromHubRequest(); + ~DetachClusterFromHubRequest(); + bool getDetachFromMesh() const; + void setDetachFromMesh(bool detachFromMesh); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string getClusterIds() const; + void setClusterIds(const std::string &clusterIds); + +private: + bool detachFromMesh_; + std::string clusterId_; + std::string clusterIds_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/DetachClusterFromHubResult.h b/adcp/include/alibabacloud/adcp/model/DetachClusterFromHubResult.h new file mode 100644 index 000000000..7702e3cd5 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/DetachClusterFromHubResult.h @@ -0,0 +1,55 @@ +/* + * 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_ADCP_MODEL_DETACHCLUSTERFROMHUBRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT DetachClusterFromHubResult : public ServiceResult + { + public: + + + DetachClusterFromHubResult(); + explicit DetachClusterFromHubResult(const std::string &payload); + ~DetachClusterFromHubResult(); + std::string getTaskId()const; + std::string getClusterId()const; + std::vector getManagedClusterIds()const; + + protected: + void parse(const std::string &payload); + private: + std::string taskId_; + std::string clusterId_; + std::vector managedClusterIds_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/GrantUserPermissionRequest.h b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionRequest.h new file mode 100644 index 000000000..c8ad23492 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionRequest.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_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionRequest : public RpcServiceRequest { +public: + GrantUserPermissionRequest(); + ~GrantUserPermissionRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + bool getIsRamRole() const; + void setIsRamRole(bool isRamRole); + std::string getRoleType() const; + void setRoleType(const std::string &roleType); + std::string getRoleName() const; + void setRoleName(const std::string &roleName); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + +private: + std::string userId_; + bool isRamRole_; + std::string roleType_; + std::string roleName_; + std::string clusterId_; + std::string _namespace_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/GrantUserPermissionResult.h b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionResult.h new file mode 100644 index 000000000..f706e8643 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionResult.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_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionResult : public ServiceResult + { + public: + + + GrantUserPermissionResult(); + explicit GrantUserPermissionResult(const std::string &payload); + ~GrantUserPermissionResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h new file mode 100644 index 000000000..74f888bda --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h @@ -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. + */ + +#ifndef ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionsRequest : public RpcServiceRequest { +public: + struct Permissions { + bool isRamRole; + std::string roleName; + std::string _namespace; + std::string roleType; + std::string clusterId; + }; + GrantUserPermissionsRequest(); + ~GrantUserPermissionsRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::vector getPermissions() const; + void setPermissions(const std::vector &permissions); + +private: + std::string userId_; + std::vector permissions_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/GrantUserPermissionsResult.h b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionsResult.h new file mode 100644 index 000000000..9eee98247 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/GrantUserPermissionsResult.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_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionsResult : public ServiceResult + { + public: + + + GrantUserPermissionsResult(); + explicit GrantUserPermissionsResult(const std::string &payload); + ~GrantUserPermissionsResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h b/adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h new file mode 100644 index 000000000..d5da3adf3 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h @@ -0,0 +1,87 @@ +/* + * 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_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT UpdateHubClusterFeatureRequest : public RpcServiceRequest { +public: + UpdateHubClusterFeatureRequest(); + ~UpdateHubClusterFeatureRequest(); + std::vector getAccessControlList() const; + void setAccessControlList(const std::vector &accessControlList); + bool getMonitorEnabled() const; + void setMonitorEnabled(bool monitorEnabled); + bool getDeletionProtection() const; + void setDeletionProtection(bool deletionProtection); + bool getEnableMesh() const; + void setEnableMesh(bool enableMesh); + bool getArgoCDHAEnabled() const; + void setArgoCDHAEnabled(bool argoCDHAEnabled); + bool getArgoCDEnabled() const; + void setArgoCDEnabled(bool argoCDEnabled); + std::vector getVSwitches() const; + void setVSwitches(const std::vector &vSwitches); + std::string getName() const; + void setName(const std::string &name); + bool getPublicAccessEnabled() const; + void setPublicAccessEnabled(bool publicAccessEnabled); + bool getPublicApiServerEnabled() const; + void setPublicApiServerEnabled(bool publicApiServerEnabled); + bool getArgoServerEnabled() const; + void setArgoServerEnabled(bool argoServerEnabled); + std::string getWorkflowScheduleMode() const; + void setWorkflowScheduleMode(const std::string &workflowScheduleMode); + bool getAuditLogEnabled() const; + void setAuditLogEnabled(bool auditLogEnabled); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string getPriceLimit() const; + void setPriceLimit(const std::string &priceLimit); + std::string getApiServerEipId() const; + void setApiServerEipId(const std::string &apiServerEipId); + +private: + std::vector accessControlList_; + bool monitorEnabled_; + bool deletionProtection_; + bool enableMesh_; + bool argoCDHAEnabled_; + bool argoCDEnabled_; + std::vector vSwitches_; + std::string name_; + bool publicAccessEnabled_; + bool publicApiServerEnabled_; + bool argoServerEnabled_; + std::string workflowScheduleMode_; + bool auditLogEnabled_; + std::string clusterId_; + std::string priceLimit_; + std::string apiServerEipId_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.h b/adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.h new file mode 100644 index 000000000..ec486d820 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.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_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT UpdateHubClusterFeatureResult : public ServiceResult + { + public: + + + UpdateHubClusterFeatureResult(); + explicit UpdateHubClusterFeatureResult(const std::string &payload); + ~UpdateHubClusterFeatureResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_ \ No newline at end of file diff --git a/adcp/include/alibabacloud/adcp/model/UpdateUserPermissionRequest.h b/adcp/include/alibabacloud/adcp/model/UpdateUserPermissionRequest.h new file mode 100644 index 000000000..f9b0f0415 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/UpdateUserPermissionRequest.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_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_ +#define ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Adcp { +namespace Model { +class ALIBABACLOUD_ADCP_EXPORT UpdateUserPermissionRequest : public RpcServiceRequest { +public: + UpdateUserPermissionRequest(); + ~UpdateUserPermissionRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getRoleType() const; + void setRoleType(const std::string &roleType); + std::string getRoleName() const; + void setRoleName(const std::string &roleName); + std::string getClusterId() const; + void setClusterId(const std::string &clusterId); + std::string get_Namespace() const; + void set_Namespace(const std::string &_namespace); + +private: + std::string userId_; + std::string roleType_; + std::string roleName_; + std::string clusterId_; + std::string _namespace_; +}; +} // namespace Model +} // namespace Adcp +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_ diff --git a/adcp/include/alibabacloud/adcp/model/UpdateUserPermissionResult.h b/adcp/include/alibabacloud/adcp/model/UpdateUserPermissionResult.h new file mode 100644 index 000000000..71802ec43 --- /dev/null +++ b/adcp/include/alibabacloud/adcp/model/UpdateUserPermissionResult.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_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_ +#define ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Adcp + { + namespace Model + { + class ALIBABACLOUD_ADCP_EXPORT UpdateUserPermissionResult : public ServiceResult + { + public: + + + UpdateUserPermissionResult(); + explicit UpdateUserPermissionResult(const std::string &payload); + ~UpdateUserPermissionResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_ \ No newline at end of file diff --git a/adcp/src/AdcpClient.cc b/adcp/src/AdcpClient.cc new file mode 100644 index 000000000..87b7faf4a --- /dev/null +++ b/adcp/src/AdcpClient.cc @@ -0,0 +1,881 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +namespace +{ + const std::string SERVICE_NAME = "adcp"; +} + +AdcpClient::AdcpClient(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, "adcp"); +} + +AdcpClient::AdcpClient(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, "adcp"); +} + +AdcpClient::AdcpClient(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, "adcp"); +} + +AdcpClient::~AdcpClient() +{} + +AdcpClient::AttachClusterToHubOutcome AdcpClient::attachClusterToHub(const AttachClusterToHubRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AttachClusterToHubOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AttachClusterToHubOutcome(AttachClusterToHubResult(outcome.result())); + else + return AttachClusterToHubOutcome(outcome.error()); +} + +void AdcpClient::attachClusterToHubAsync(const AttachClusterToHubRequest& request, const AttachClusterToHubAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, attachClusterToHub(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::AttachClusterToHubOutcomeCallable AdcpClient::attachClusterToHubCallable(const AttachClusterToHubRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->attachClusterToHub(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::CreateHubClusterOutcome AdcpClient::createHubCluster(const CreateHubClusterRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateHubClusterOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateHubClusterOutcome(CreateHubClusterResult(outcome.result())); + else + return CreateHubClusterOutcome(outcome.error()); +} + +void AdcpClient::createHubClusterAsync(const CreateHubClusterRequest& request, const CreateHubClusterAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createHubCluster(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::CreateHubClusterOutcomeCallable AdcpClient::createHubClusterCallable(const CreateHubClusterRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createHubCluster(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DeleteHubClusterOutcome AdcpClient::deleteHubCluster(const DeleteHubClusterRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteHubClusterOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteHubClusterOutcome(DeleteHubClusterResult(outcome.result())); + else + return DeleteHubClusterOutcome(outcome.error()); +} + +void AdcpClient::deleteHubClusterAsync(const DeleteHubClusterRequest& request, const DeleteHubClusterAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteHubCluster(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DeleteHubClusterOutcomeCallable AdcpClient::deleteHubClusterCallable(const DeleteHubClusterRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteHubCluster(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DeletePolicyInstanceOutcome AdcpClient::deletePolicyInstance(const DeletePolicyInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeletePolicyInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeletePolicyInstanceOutcome(DeletePolicyInstanceResult(outcome.result())); + else + return DeletePolicyInstanceOutcome(outcome.error()); +} + +void AdcpClient::deletePolicyInstanceAsync(const DeletePolicyInstanceRequest& request, const DeletePolicyInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deletePolicyInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DeletePolicyInstanceOutcomeCallable AdcpClient::deletePolicyInstanceCallable(const DeletePolicyInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deletePolicyInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DeleteUserPermissionOutcome AdcpClient::deleteUserPermission(const DeleteUserPermissionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteUserPermissionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteUserPermissionOutcome(DeleteUserPermissionResult(outcome.result())); + else + return DeleteUserPermissionOutcome(outcome.error()); +} + +void AdcpClient::deleteUserPermissionAsync(const DeleteUserPermissionRequest& request, const DeleteUserPermissionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteUserPermission(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DeleteUserPermissionOutcomeCallable AdcpClient::deleteUserPermissionCallable(const DeleteUserPermissionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteUserPermission(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DeployPolicyInstanceOutcome AdcpClient::deployPolicyInstance(const DeployPolicyInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeployPolicyInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeployPolicyInstanceOutcome(DeployPolicyInstanceResult(outcome.result())); + else + return DeployPolicyInstanceOutcome(outcome.error()); +} + +void AdcpClient::deployPolicyInstanceAsync(const DeployPolicyInstanceRequest& request, const DeployPolicyInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deployPolicyInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DeployPolicyInstanceOutcomeCallable AdcpClient::deployPolicyInstanceCallable(const DeployPolicyInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deployPolicyInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribeHubClusterDetailsOutcome AdcpClient::describeHubClusterDetails(const DescribeHubClusterDetailsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeHubClusterDetailsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeHubClusterDetailsOutcome(DescribeHubClusterDetailsResult(outcome.result())); + else + return DescribeHubClusterDetailsOutcome(outcome.error()); +} + +void AdcpClient::describeHubClusterDetailsAsync(const DescribeHubClusterDetailsRequest& request, const DescribeHubClusterDetailsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeHubClusterDetails(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribeHubClusterDetailsOutcomeCallable AdcpClient::describeHubClusterDetailsCallable(const DescribeHubClusterDetailsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeHubClusterDetails(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribeHubClusterKubeconfigOutcome AdcpClient::describeHubClusterKubeconfig(const DescribeHubClusterKubeconfigRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeHubClusterKubeconfigOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeHubClusterKubeconfigOutcome(DescribeHubClusterKubeconfigResult(outcome.result())); + else + return DescribeHubClusterKubeconfigOutcome(outcome.error()); +} + +void AdcpClient::describeHubClusterKubeconfigAsync(const DescribeHubClusterKubeconfigRequest& request, const DescribeHubClusterKubeconfigAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeHubClusterKubeconfig(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribeHubClusterKubeconfigOutcomeCallable AdcpClient::describeHubClusterKubeconfigCallable(const DescribeHubClusterKubeconfigRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeHubClusterKubeconfig(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribeHubClusterLogsOutcome AdcpClient::describeHubClusterLogs(const DescribeHubClusterLogsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeHubClusterLogsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeHubClusterLogsOutcome(DescribeHubClusterLogsResult(outcome.result())); + else + return DescribeHubClusterLogsOutcome(outcome.error()); +} + +void AdcpClient::describeHubClusterLogsAsync(const DescribeHubClusterLogsRequest& request, const DescribeHubClusterLogsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeHubClusterLogs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribeHubClusterLogsOutcomeCallable AdcpClient::describeHubClusterLogsCallable(const DescribeHubClusterLogsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeHubClusterLogs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribeHubClustersOutcome AdcpClient::describeHubClusters(const DescribeHubClustersRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeHubClustersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeHubClustersOutcome(DescribeHubClustersResult(outcome.result())); + else + return DescribeHubClustersOutcome(outcome.error()); +} + +void AdcpClient::describeHubClustersAsync(const DescribeHubClustersRequest& request, const DescribeHubClustersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeHubClusters(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribeHubClustersOutcomeCallable AdcpClient::describeHubClustersCallable(const DescribeHubClustersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeHubClusters(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribeManagedClustersOutcome AdcpClient::describeManagedClusters(const DescribeManagedClustersRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeManagedClustersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeManagedClustersOutcome(DescribeManagedClustersResult(outcome.result())); + else + return DescribeManagedClustersOutcome(outcome.error()); +} + +void AdcpClient::describeManagedClustersAsync(const DescribeManagedClustersRequest& request, const DescribeManagedClustersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeManagedClusters(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribeManagedClustersOutcomeCallable AdcpClient::describeManagedClustersCallable(const DescribeManagedClustersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeManagedClusters(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribePoliciesOutcome AdcpClient::describePolicies(const DescribePoliciesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribePoliciesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribePoliciesOutcome(DescribePoliciesResult(outcome.result())); + else + return DescribePoliciesOutcome(outcome.error()); +} + +void AdcpClient::describePoliciesAsync(const DescribePoliciesRequest& request, const DescribePoliciesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describePolicies(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribePoliciesOutcomeCallable AdcpClient::describePoliciesCallable(const DescribePoliciesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describePolicies(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribePolicyDetailsOutcome AdcpClient::describePolicyDetails(const DescribePolicyDetailsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribePolicyDetailsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribePolicyDetailsOutcome(DescribePolicyDetailsResult(outcome.result())); + else + return DescribePolicyDetailsOutcome(outcome.error()); +} + +void AdcpClient::describePolicyDetailsAsync(const DescribePolicyDetailsRequest& request, const DescribePolicyDetailsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describePolicyDetails(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribePolicyDetailsOutcomeCallable AdcpClient::describePolicyDetailsCallable(const DescribePolicyDetailsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describePolicyDetails(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribePolicyGovernanceInClusterOutcome AdcpClient::describePolicyGovernanceInCluster(const DescribePolicyGovernanceInClusterRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribePolicyGovernanceInClusterOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribePolicyGovernanceInClusterOutcome(DescribePolicyGovernanceInClusterResult(outcome.result())); + else + return DescribePolicyGovernanceInClusterOutcome(outcome.error()); +} + +void AdcpClient::describePolicyGovernanceInClusterAsync(const DescribePolicyGovernanceInClusterRequest& request, const DescribePolicyGovernanceInClusterAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describePolicyGovernanceInCluster(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribePolicyGovernanceInClusterOutcomeCallable AdcpClient::describePolicyGovernanceInClusterCallable(const DescribePolicyGovernanceInClusterRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describePolicyGovernanceInCluster(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribePolicyInstancesOutcome AdcpClient::describePolicyInstances(const DescribePolicyInstancesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribePolicyInstancesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribePolicyInstancesOutcome(DescribePolicyInstancesResult(outcome.result())); + else + return DescribePolicyInstancesOutcome(outcome.error()); +} + +void AdcpClient::describePolicyInstancesAsync(const DescribePolicyInstancesRequest& request, const DescribePolicyInstancesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describePolicyInstances(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribePolicyInstancesOutcomeCallable AdcpClient::describePolicyInstancesCallable(const DescribePolicyInstancesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describePolicyInstances(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribePolicyInstancesStatusOutcome AdcpClient::describePolicyInstancesStatus(const DescribePolicyInstancesStatusRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribePolicyInstancesStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribePolicyInstancesStatusOutcome(DescribePolicyInstancesStatusResult(outcome.result())); + else + return DescribePolicyInstancesStatusOutcome(outcome.error()); +} + +void AdcpClient::describePolicyInstancesStatusAsync(const DescribePolicyInstancesStatusRequest& request, const DescribePolicyInstancesStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describePolicyInstancesStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribePolicyInstancesStatusOutcomeCallable AdcpClient::describePolicyInstancesStatusCallable(const DescribePolicyInstancesStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describePolicyInstancesStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DescribeRegionsOutcome AdcpClient::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 AdcpClient::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)); +} + +AdcpClient::DescribeRegionsOutcomeCallable AdcpClient::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(); +} + +AdcpClient::DescribeUserPermissionsOutcome AdcpClient::describeUserPermissions(const DescribeUserPermissionsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeUserPermissionsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeUserPermissionsOutcome(DescribeUserPermissionsResult(outcome.result())); + else + return DescribeUserPermissionsOutcome(outcome.error()); +} + +void AdcpClient::describeUserPermissionsAsync(const DescribeUserPermissionsRequest& request, const DescribeUserPermissionsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeUserPermissions(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DescribeUserPermissionsOutcomeCallable AdcpClient::describeUserPermissionsCallable(const DescribeUserPermissionsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeUserPermissions(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::DetachClusterFromHubOutcome AdcpClient::detachClusterFromHub(const DetachClusterFromHubRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DetachClusterFromHubOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DetachClusterFromHubOutcome(DetachClusterFromHubResult(outcome.result())); + else + return DetachClusterFromHubOutcome(outcome.error()); +} + +void AdcpClient::detachClusterFromHubAsync(const DetachClusterFromHubRequest& request, const DetachClusterFromHubAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, detachClusterFromHub(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::DetachClusterFromHubOutcomeCallable AdcpClient::detachClusterFromHubCallable(const DetachClusterFromHubRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->detachClusterFromHub(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::GrantUserPermissionOutcome AdcpClient::grantUserPermission(const GrantUserPermissionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GrantUserPermissionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GrantUserPermissionOutcome(GrantUserPermissionResult(outcome.result())); + else + return GrantUserPermissionOutcome(outcome.error()); +} + +void AdcpClient::grantUserPermissionAsync(const GrantUserPermissionRequest& request, const GrantUserPermissionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, grantUserPermission(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::GrantUserPermissionOutcomeCallable AdcpClient::grantUserPermissionCallable(const GrantUserPermissionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->grantUserPermission(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::GrantUserPermissionsOutcome AdcpClient::grantUserPermissions(const GrantUserPermissionsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GrantUserPermissionsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GrantUserPermissionsOutcome(GrantUserPermissionsResult(outcome.result())); + else + return GrantUserPermissionsOutcome(outcome.error()); +} + +void AdcpClient::grantUserPermissionsAsync(const GrantUserPermissionsRequest& request, const GrantUserPermissionsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, grantUserPermissions(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::GrantUserPermissionsOutcomeCallable AdcpClient::grantUserPermissionsCallable(const GrantUserPermissionsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->grantUserPermissions(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::UpdateHubClusterFeatureOutcome AdcpClient::updateHubClusterFeature(const UpdateHubClusterFeatureRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateHubClusterFeatureOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateHubClusterFeatureOutcome(UpdateHubClusterFeatureResult(outcome.result())); + else + return UpdateHubClusterFeatureOutcome(outcome.error()); +} + +void AdcpClient::updateHubClusterFeatureAsync(const UpdateHubClusterFeatureRequest& request, const UpdateHubClusterFeatureAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateHubClusterFeature(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::UpdateHubClusterFeatureOutcomeCallable AdcpClient::updateHubClusterFeatureCallable(const UpdateHubClusterFeatureRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateHubClusterFeature(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AdcpClient::UpdateUserPermissionOutcome AdcpClient::updateUserPermission(const UpdateUserPermissionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateUserPermissionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateUserPermissionOutcome(UpdateUserPermissionResult(outcome.result())); + else + return UpdateUserPermissionOutcome(outcome.error()); +} + +void AdcpClient::updateUserPermissionAsync(const UpdateUserPermissionRequest& request, const UpdateUserPermissionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateUserPermission(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AdcpClient::UpdateUserPermissionOutcomeCallable AdcpClient::updateUserPermissionCallable(const UpdateUserPermissionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateUserPermission(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/adcp/src/model/AttachClusterToHubRequest.cc b/adcp/src/model/AttachClusterToHubRequest.cc new file mode 100644 index 000000000..3f5cdb8d7 --- /dev/null +++ b/adcp/src/model/AttachClusterToHubRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Adcp::Model::AttachClusterToHubRequest; + +AttachClusterToHubRequest::AttachClusterToHubRequest() + : RpcServiceRequest("adcp", "2022-01-01", "AttachClusterToHub") { + setMethod(HttpRequest::Method::Post); +} + +AttachClusterToHubRequest::~AttachClusterToHubRequest() {} + +std::string AttachClusterToHubRequest::getClusterId() const { + return clusterId_; +} + +void AttachClusterToHubRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string AttachClusterToHubRequest::getClusterIds() const { + return clusterIds_; +} + +void AttachClusterToHubRequest::setClusterIds(const std::string &clusterIds) { + clusterIds_ = clusterIds; + setBodyParameter(std::string("ClusterIds"), clusterIds); +} + +bool AttachClusterToHubRequest::getAttachToMesh() const { + return attachToMesh_; +} + +void AttachClusterToHubRequest::setAttachToMesh(bool attachToMesh) { + attachToMesh_ = attachToMesh; + setParameter(std::string("AttachToMesh"), attachToMesh ? "true" : "false"); +} + diff --git a/adcp/src/model/AttachClusterToHubResult.cc b/adcp/src/model/AttachClusterToHubResult.cc new file mode 100644 index 000000000..b11ff2cbd --- /dev/null +++ b/adcp/src/model/AttachClusterToHubResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +AttachClusterToHubResult::AttachClusterToHubResult() : + ServiceResult() +{} + +AttachClusterToHubResult::AttachClusterToHubResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AttachClusterToHubResult::~AttachClusterToHubResult() +{} + +void AttachClusterToHubResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allManagedClusterIds = value["ManagedClusterIds"]["ManagedClusterId"]; + for (const auto &item : allManagedClusterIds) + managedClusterIds_.push_back(item.asString()); + if(!value["ClusterId"].isNull()) + clusterId_ = value["ClusterId"].asString(); + if(!value["TaskId"].isNull()) + taskId_ = value["TaskId"].asString(); + +} + +std::string AttachClusterToHubResult::getTaskId()const +{ + return taskId_; +} + +std::string AttachClusterToHubResult::getClusterId()const +{ + return clusterId_; +} + +std::vector AttachClusterToHubResult::getManagedClusterIds()const +{ + return managedClusterIds_; +} + diff --git a/adcp/src/model/CreateHubClusterRequest.cc b/adcp/src/model/CreateHubClusterRequest.cc new file mode 100644 index 000000000..a4287d4d2 --- /dev/null +++ b/adcp/src/model/CreateHubClusterRequest.cc @@ -0,0 +1,250 @@ +/* + * 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::Adcp::Model::CreateHubClusterRequest; + +CreateHubClusterRequest::CreateHubClusterRequest() + : RpcServiceRequest("adcp", "2022-01-01", "CreateHubCluster") { + setMethod(HttpRequest::Method::Post); +} + +CreateHubClusterRequest::~CreateHubClusterRequest() {} + +std::string CreateHubClusterRequest::getAuditLogProject() const { + return auditLogProject_; +} + +void CreateHubClusterRequest::setAuditLogProject(const std::string &auditLogProject) { + auditLogProject_ = auditLogProject; + setBodyParameter(std::string("AuditLogProject"), auditLogProject); +} + +std::string CreateHubClusterRequest::getLoadBalancerSpec() const { + return loadBalancerSpec_; +} + +void CreateHubClusterRequest::setLoadBalancerSpec(const std::string &loadBalancerSpec) { + loadBalancerSpec_ = loadBalancerSpec; + setBodyParameter(std::string("LoadBalancerSpec"), loadBalancerSpec); +} + +std::string CreateHubClusterRequest::getKubernetesVersion() const { + return kubernetesVersion_; +} + +void CreateHubClusterRequest::setKubernetesVersion(const std::string &kubernetesVersion) { + kubernetesVersion_ = kubernetesVersion; + setBodyParameter(std::string("KubernetesVersion"), kubernetesVersion); +} + +std::string CreateHubClusterRequest::getProfile() const { + return profile_; +} + +void CreateHubClusterRequest::setProfile(const std::string &profile) { + profile_ = profile; + setBodyParameter(std::string("Profile"), profile); +} + +std::string CreateHubClusterRequest::getVSwitches() const { + return vSwitches_; +} + +void CreateHubClusterRequest::setVSwitches(const std::string &vSwitches) { + vSwitches_ = vSwitches; + setBodyParameter(std::string("VSwitches"), vSwitches); +} + +std::string CreateHubClusterRequest::getControlPlaneLogProject() const { + return controlPlaneLogProject_; +} + +void CreateHubClusterRequest::setControlPlaneLogProject(const std::string &controlPlaneLogProject) { + controlPlaneLogProject_ = controlPlaneLogProject; + setBodyParameter(std::string("ControlPlaneLogProject"), controlPlaneLogProject); +} + +std::string CreateHubClusterRequest::getLoadBalancerId() const { + return loadBalancerId_; +} + +void CreateHubClusterRequest::setLoadBalancerId(const std::string &loadBalancerId) { + loadBalancerId_ = loadBalancerId; + setBodyParameter(std::string("LoadBalancerId"), loadBalancerId); +} + +std::string CreateHubClusterRequest::getClusterSpec() const { + return clusterSpec_; +} + +void CreateHubClusterRequest::setClusterSpec(const std::string &clusterSpec) { + clusterSpec_ = clusterSpec; + setBodyParameter(std::string("ClusterSpec"), clusterSpec); +} + +std::string CreateHubClusterRequest::getName() const { + return name_; +} + +void CreateHubClusterRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +std::string CreateHubClusterRequest::getClusterDomain() const { + return clusterDomain_; +} + +void CreateHubClusterRequest::setClusterDomain(const std::string &clusterDomain) { + clusterDomain_ = clusterDomain; + setBodyParameter(std::string("ClusterDomain"), clusterDomain); +} + +std::string CreateHubClusterRequest::getControlPlaneLogTTL() const { + return controlPlaneLogTTL_; +} + +void CreateHubClusterRequest::setControlPlaneLogTTL(const std::string &controlPlaneLogTTL) { + controlPlaneLogTTL_ = controlPlaneLogTTL; + setBodyParameter(std::string("ControlPlaneLogTTL"), controlPlaneLogTTL); +} + +std::vector CreateHubClusterRequest::getWorkflowUnits() const { + return workflowUnits_; +} + +void CreateHubClusterRequest::setWorkflowUnits(const std::vector &workflowUnits) { + workflowUnits_ = workflowUnits; + for(int dep1 = 0; dep1 != workflowUnits.size(); dep1++) { + setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".RegionId", workflowUnits[dep1].regionId); + setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".VpcId", workflowUnits[dep1].vpcId); + for(int dep2 = 0; dep2 != workflowUnits[dep1].vSwitches.size(); dep2++) { + setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".VSwitches." + std::to_string(dep2 + 1) + ".VswitchId", workflowUnits[dep1].vSwitches[dep2].vswitchId); + setBodyParameter(std::string("WorkflowUnits") + "." + std::to_string(dep1 + 1) + ".VSwitches." + std::to_string(dep2 + 1) + ".ZoneId", workflowUnits[dep1].vSwitches[dep2].zoneId); + } + } +} + +std::string CreateHubClusterRequest::getRegionId() const { + return regionId_; +} + +void CreateHubClusterRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string CreateHubClusterRequest::getAuditLogStoreTTL() const { + return auditLogStoreTTL_; +} + +void CreateHubClusterRequest::setAuditLogStoreTTL(const std::string &auditLogStoreTTL) { + auditLogStoreTTL_ = auditLogStoreTTL; + setBodyParameter(std::string("AuditLogStoreTTL"), auditLogStoreTTL); +} + +std::string CreateHubClusterRequest::getIPStack() const { + return iPStack_; +} + +void CreateHubClusterRequest::setIPStack(const std::string &iPStack) { + iPStack_ = iPStack; + setBodyParameter(std::string("IPStack"), iPStack); +} + +bool CreateHubClusterRequest::getControlPlaneLogEnabled() const { + return controlPlaneLogEnabled_; +} + +void CreateHubClusterRequest::setControlPlaneLogEnabled(bool controlPlaneLogEnabled) { + controlPlaneLogEnabled_ = controlPlaneLogEnabled; + setBodyParameter(std::string("ControlPlaneLogEnabled"), controlPlaneLogEnabled ? "true" : "false"); +} + +bool CreateHubClusterRequest::getArgoServerEnabled() const { + return argoServerEnabled_; +} + +void CreateHubClusterRequest::setArgoServerEnabled(bool argoServerEnabled) { + argoServerEnabled_ = argoServerEnabled; + setBodyParameter(std::string("ArgoServerEnabled"), argoServerEnabled ? "true" : "false"); +} + +std::string CreateHubClusterRequest::getWorkflowScheduleMode() const { + return workflowScheduleMode_; +} + +void CreateHubClusterRequest::setWorkflowScheduleMode(const std::string &workflowScheduleMode) { + workflowScheduleMode_ = workflowScheduleMode; + setBodyParameter(std::string("WorkflowScheduleMode"), workflowScheduleMode); +} + +bool CreateHubClusterRequest::getApiServerPublicEip() const { + return apiServerPublicEip_; +} + +void CreateHubClusterRequest::setApiServerPublicEip(bool apiServerPublicEip) { + apiServerPublicEip_ = apiServerPublicEip; + setBodyParameter(std::string("ApiServerPublicEip"), apiServerPublicEip ? "true" : "false"); +} + +bool CreateHubClusterRequest::getAuditLogEnabled() const { + return auditLogEnabled_; +} + +void CreateHubClusterRequest::setAuditLogEnabled(bool auditLogEnabled) { + auditLogEnabled_ = auditLogEnabled; + setBodyParameter(std::string("AuditLogEnabled"), auditLogEnabled ? "true" : "false"); +} + +std::string CreateHubClusterRequest::getSecurityGroupIDs() const { + return securityGroupIDs_; +} + +void CreateHubClusterRequest::setSecurityGroupIDs(const std::string &securityGroupIDs) { + securityGroupIDs_ = securityGroupIDs; + setBodyParameter(std::string("SecurityGroupIDs"), securityGroupIDs); +} + +std::string CreateHubClusterRequest::getPriceLimit() const { + return priceLimit_; +} + +void CreateHubClusterRequest::setPriceLimit(const std::string &priceLimit) { + priceLimit_ = priceLimit; + setBodyParameter(std::string("PriceLimit"), priceLimit); +} + +bool CreateHubClusterRequest::getIsEnterpriseSecurityGroup() const { + return isEnterpriseSecurityGroup_; +} + +void CreateHubClusterRequest::setIsEnterpriseSecurityGroup(bool isEnterpriseSecurityGroup) { + isEnterpriseSecurityGroup_ = isEnterpriseSecurityGroup; + setBodyParameter(std::string("IsEnterpriseSecurityGroup"), isEnterpriseSecurityGroup ? "true" : "false"); +} + +std::string CreateHubClusterRequest::getVpcId() const { + return vpcId_; +} + +void CreateHubClusterRequest::setVpcId(const std::string &vpcId) { + vpcId_ = vpcId; + setBodyParameter(std::string("VpcId"), vpcId); +} + diff --git a/adcp/src/model/CreateHubClusterResult.cc b/adcp/src/model/CreateHubClusterResult.cc new file mode 100644 index 000000000..7dac19502 --- /dev/null +++ b/adcp/src/model/CreateHubClusterResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +CreateHubClusterResult::CreateHubClusterResult() : + ServiceResult() +{} + +CreateHubClusterResult::CreateHubClusterResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateHubClusterResult::~CreateHubClusterResult() +{} + +void CreateHubClusterResult::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["TaskId"].isNull()) + taskId_ = value["TaskId"].asString(); + +} + +std::string CreateHubClusterResult::getTaskId()const +{ + return taskId_; +} + +std::string CreateHubClusterResult::getClusterId()const +{ + return clusterId_; +} + diff --git a/adcp/src/model/DeleteHubClusterRequest.cc b/adcp/src/model/DeleteHubClusterRequest.cc new file mode 100644 index 000000000..17fa9495e --- /dev/null +++ b/adcp/src/model/DeleteHubClusterRequest.cc @@ -0,0 +1,56 @@ +/* + * 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::Adcp::Model::DeleteHubClusterRequest; + +DeleteHubClusterRequest::DeleteHubClusterRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DeleteHubCluster") { + setMethod(HttpRequest::Method::Post); +} + +DeleteHubClusterRequest::~DeleteHubClusterRequest() {} + +std::vector DeleteHubClusterRequest::getRetainResources() const { + return retainResources_; +} + +void DeleteHubClusterRequest::setRetainResources(const std::vector &retainResources) { + retainResources_ = retainResources; + for(int dep1 = 0; dep1 != retainResources.size(); dep1++) { + setParameter(std::string("RetainResources") + "." + std::to_string(dep1 + 1), retainResources[dep1]); + } +} + +std::string DeleteHubClusterRequest::getClusterId() const { + return clusterId_; +} + +void DeleteHubClusterRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +bool DeleteHubClusterRequest::getForce() const { + return force_; +} + +void DeleteHubClusterRequest::setForce(bool force) { + force_ = force; + setParameter(std::string("Force"), force ? "true" : "false"); +} + diff --git a/adcp/src/model/DeleteHubClusterResult.cc b/adcp/src/model/DeleteHubClusterResult.cc new file mode 100644 index 000000000..54e2c69ab --- /dev/null +++ b/adcp/src/model/DeleteHubClusterResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DeleteHubClusterResult::DeleteHubClusterResult() : + ServiceResult() +{} + +DeleteHubClusterResult::DeleteHubClusterResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteHubClusterResult::~DeleteHubClusterResult() +{} + +void DeleteHubClusterResult::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["TaskId"].isNull()) + taskId_ = value["TaskId"].asString(); + +} + +std::string DeleteHubClusterResult::getTaskId()const +{ + return taskId_; +} + +std::string DeleteHubClusterResult::getClusterId()const +{ + return clusterId_; +} + diff --git a/adcp/src/model/DeletePolicyInstanceRequest.cc b/adcp/src/model/DeletePolicyInstanceRequest.cc new file mode 100644 index 000000000..3812b0889 --- /dev/null +++ b/adcp/src/model/DeletePolicyInstanceRequest.cc @@ -0,0 +1,56 @@ +/* + * 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::Adcp::Model::DeletePolicyInstanceRequest; + +DeletePolicyInstanceRequest::DeletePolicyInstanceRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DeletePolicyInstance") { + setMethod(HttpRequest::Method::Post); +} + +DeletePolicyInstanceRequest::~DeletePolicyInstanceRequest() {} + +std::string DeletePolicyInstanceRequest::getClusterId() const { + return clusterId_; +} + +void DeletePolicyInstanceRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::vector DeletePolicyInstanceRequest::getClusterIds() const { + return clusterIds_; +} + +void DeletePolicyInstanceRequest::setClusterIds(const std::vector &clusterIds) { + clusterIds_ = clusterIds; + for(int dep1 = 0; dep1 != clusterIds.size(); dep1++) { + setParameter(std::string("ClusterIds") + "." + std::to_string(dep1 + 1), clusterIds[dep1]); + } +} + +std::string DeletePolicyInstanceRequest::getPolicyName() const { + return policyName_; +} + +void DeletePolicyInstanceRequest::setPolicyName(const std::string &policyName) { + policyName_ = policyName; + setParameter(std::string("PolicyName"), policyName); +} + diff --git a/adcp/src/model/DeletePolicyInstanceResult.cc b/adcp/src/model/DeletePolicyInstanceResult.cc new file mode 100644 index 000000000..432bdead4 --- /dev/null +++ b/adcp/src/model/DeletePolicyInstanceResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DeletePolicyInstanceResult::DeletePolicyInstanceResult() : + ServiceResult() +{} + +DeletePolicyInstanceResult::DeletePolicyInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeletePolicyInstanceResult::~DeletePolicyInstanceResult() +{} + +void DeletePolicyInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/adcp/src/model/DeleteUserPermissionRequest.cc b/adcp/src/model/DeleteUserPermissionRequest.cc new file mode 100644 index 000000000..44f6b3ca4 --- /dev/null +++ b/adcp/src/model/DeleteUserPermissionRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Adcp::Model::DeleteUserPermissionRequest; + +DeleteUserPermissionRequest::DeleteUserPermissionRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DeleteUserPermission") { + setMethod(HttpRequest::Method::Post); +} + +DeleteUserPermissionRequest::~DeleteUserPermissionRequest() {} + +std::string DeleteUserPermissionRequest::getUserId() const { + return userId_; +} + +void DeleteUserPermissionRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string DeleteUserPermissionRequest::getClusterId() const { + return clusterId_; +} + +void DeleteUserPermissionRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + diff --git a/adcp/src/model/DeleteUserPermissionResult.cc b/adcp/src/model/DeleteUserPermissionResult.cc new file mode 100644 index 000000000..f979adfde --- /dev/null +++ b/adcp/src/model/DeleteUserPermissionResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DeleteUserPermissionResult::DeleteUserPermissionResult() : + ServiceResult() +{} + +DeleteUserPermissionResult::DeleteUserPermissionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteUserPermissionResult::~DeleteUserPermissionResult() +{} + +void DeleteUserPermissionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/adcp/src/model/DeployPolicyInstanceRequest.cc b/adcp/src/model/DeployPolicyInstanceRequest.cc new file mode 100644 index 000000000..d621a425f --- /dev/null +++ b/adcp/src/model/DeployPolicyInstanceRequest.cc @@ -0,0 +1,76 @@ +/* + * 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::Adcp::Model::DeployPolicyInstanceRequest; + +DeployPolicyInstanceRequest::DeployPolicyInstanceRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DeployPolicyInstance") { + setMethod(HttpRequest::Method::Post); +} + +DeployPolicyInstanceRequest::~DeployPolicyInstanceRequest() {} + +std::string DeployPolicyInstanceRequest::getClusterId() const { + return clusterId_; +} + +void DeployPolicyInstanceRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string DeployPolicyInstanceRequest::getPolicyAction() const { + return policyAction_; +} + +void DeployPolicyInstanceRequest::setPolicyAction(const std::string &policyAction) { + policyAction_ = policyAction; + setParameter(std::string("PolicyAction"), policyAction); +} + +std::vector DeployPolicyInstanceRequest::getClusterIds() const { + return clusterIds_; +} + +void DeployPolicyInstanceRequest::setClusterIds(const std::vector &clusterIds) { + clusterIds_ = clusterIds; + for(int dep1 = 0; dep1 != clusterIds.size(); dep1++) { + setParameter(std::string("ClusterIds") + "." + std::to_string(dep1 + 1), clusterIds[dep1]); + } +} + +std::string DeployPolicyInstanceRequest::getPolicyName() const { + return policyName_; +} + +void DeployPolicyInstanceRequest::setPolicyName(const std::string &policyName) { + policyName_ = policyName; + setParameter(std::string("PolicyName"), policyName); +} + +std::vector DeployPolicyInstanceRequest::getNamespaces() const { + return namespaces_; +} + +void DeployPolicyInstanceRequest::setNamespaces(const std::vector &namespaces) { + namespaces_ = namespaces; + for(int dep1 = 0; dep1 != namespaces.size(); dep1++) { + setParameter(std::string("Namespaces") + "." + std::to_string(dep1 + 1), namespaces[dep1]); + } +} + diff --git a/adcp/src/model/DeployPolicyInstanceResult.cc b/adcp/src/model/DeployPolicyInstanceResult.cc new file mode 100644 index 000000000..6874758b0 --- /dev/null +++ b/adcp/src/model/DeployPolicyInstanceResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DeployPolicyInstanceResult::DeployPolicyInstanceResult() : + ServiceResult() +{} + +DeployPolicyInstanceResult::DeployPolicyInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeployPolicyInstanceResult::~DeployPolicyInstanceResult() +{} + +void DeployPolicyInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/adcp/src/model/DescribeHubClusterDetailsRequest.cc b/adcp/src/model/DescribeHubClusterDetailsRequest.cc new file mode 100644 index 000000000..0a5afe087 --- /dev/null +++ b/adcp/src/model/DescribeHubClusterDetailsRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribeHubClusterDetailsRequest; + +DescribeHubClusterDetailsRequest::DescribeHubClusterDetailsRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusterDetails") { + setMethod(HttpRequest::Method::Post); +} + +DescribeHubClusterDetailsRequest::~DescribeHubClusterDetailsRequest() {} + +std::string DescribeHubClusterDetailsRequest::getClusterId() const { + return clusterId_; +} + +void DescribeHubClusterDetailsRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + diff --git a/adcp/src/model/DescribeHubClusterDetailsResult.cc b/adcp/src/model/DescribeHubClusterDetailsResult.cc new file mode 100644 index 000000000..4cbf26b9a --- /dev/null +++ b/adcp/src/model/DescribeHubClusterDetailsResult.cc @@ -0,0 +1,149 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribeHubClusterDetailsResult::DescribeHubClusterDetailsResult() : + ServiceResult() +{} + +DescribeHubClusterDetailsResult::DescribeHubClusterDetailsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeHubClusterDetailsResult::~DescribeHubClusterDetailsResult() +{} + +void DescribeHubClusterDetailsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto clusterNode = value["Cluster"]; + auto allConditionsNode = clusterNode["Conditions"]["Condition"]; + for (auto clusterNodeConditionsCondition : allConditionsNode) + { + Cluster::Condition conditionObject; + if(!clusterNodeConditionsCondition["Type"].isNull()) + conditionObject.type = clusterNodeConditionsCondition["Type"].asString(); + if(!clusterNodeConditionsCondition["Status"].isNull()) + conditionObject.status = clusterNodeConditionsCondition["Status"].asString(); + if(!clusterNodeConditionsCondition["Reason"].isNull()) + conditionObject.reason = clusterNodeConditionsCondition["Reason"].asString(); + if(!clusterNodeConditionsCondition["Message"].isNull()) + conditionObject.message = clusterNodeConditionsCondition["Message"].asString(); + cluster_.conditions.push_back(conditionObject); + } + auto endpointsNode = clusterNode["Endpoints"]; + if(!endpointsNode["IntranetApiServerEndpoint"].isNull()) + cluster_.endpoints.intranetApiServerEndpoint = endpointsNode["IntranetApiServerEndpoint"].asString(); + if(!endpointsNode["PublicApiServerEndpoint"].isNull()) + cluster_.endpoints.publicApiServerEndpoint = endpointsNode["PublicApiServerEndpoint"].asString(); + auto clusterInfoNode = clusterNode["ClusterInfo"]; + if(!clusterInfoNode["Profile"].isNull()) + cluster_.clusterInfo.profile = clusterInfoNode["Profile"].asString(); + if(!clusterInfoNode["CreationTime"].isNull()) + cluster_.clusterInfo.creationTime = clusterInfoNode["CreationTime"].asString(); + if(!clusterInfoNode["UpdateTime"].isNull()) + cluster_.clusterInfo.updateTime = clusterInfoNode["UpdateTime"].asString(); + if(!clusterInfoNode["ErrorMessage"].isNull()) + cluster_.clusterInfo.errorMessage = clusterInfoNode["ErrorMessage"].asString(); + if(!clusterInfoNode["Version"].isNull()) + cluster_.clusterInfo.version = clusterInfoNode["Version"].asString(); + if(!clusterInfoNode["State"].isNull()) + cluster_.clusterInfo.state = clusterInfoNode["State"].asString(); + if(!clusterInfoNode["ClusterId"].isNull()) + cluster_.clusterInfo.clusterId = clusterInfoNode["ClusterId"].asString(); + if(!clusterInfoNode["Name"].isNull()) + cluster_.clusterInfo.name = clusterInfoNode["Name"].asString(); + if(!clusterInfoNode["RegionId"].isNull()) + cluster_.clusterInfo.regionId = clusterInfoNode["RegionId"].asString(); + if(!clusterInfoNode["ClusterSpec"].isNull()) + cluster_.clusterInfo.clusterSpec = clusterInfoNode["ClusterSpec"].asString(); + auto networkNode = clusterNode["Network"]; + if(!networkNode["VpcId"].isNull()) + cluster_.network.vpcId = networkNode["VpcId"].asString(); + if(!networkNode["IPStack"].isNull()) + cluster_.network.iPStack = networkNode["IPStack"].asString(); + if(!networkNode["ClusterDomain"].isNull()) + cluster_.network.clusterDomain = networkNode["ClusterDomain"].asString(); + auto allVSwitches = networkNode["VSwitches"]["VSwitches"]; + for (auto value : allVSwitches) + cluster_.network.vSwitches.push_back(value.asString()); + auto allSecurityGroupIDs = networkNode["SecurityGroupIDs"]["SecurityGroupIDs"]; + for (auto value : allSecurityGroupIDs) + cluster_.network.securityGroupIDs.push_back(value.asString()); + auto apiServerNode = clusterNode["ApiServer"]; + if(!apiServerNode["EnabledPublic"].isNull()) + cluster_.apiServer.enabledPublic = apiServerNode["EnabledPublic"].asString() == "true"; + if(!apiServerNode["LoadBalancerId"].isNull()) + cluster_.apiServer.loadBalancerId = apiServerNode["LoadBalancerId"].asString(); + if(!apiServerNode["ApiServerEipId"].isNull()) + cluster_.apiServer.apiServerEipId = apiServerNode["ApiServerEipId"].asString(); + auto meshConfigNode = clusterNode["MeshConfig"]; + if(!meshConfigNode["EnableMesh"].isNull()) + cluster_.meshConfig.enableMesh = meshConfigNode["EnableMesh"].asString() == "true"; + if(!meshConfigNode["MeshId"].isNull()) + cluster_.meshConfig.meshId = meshConfigNode["MeshId"].asString(); + auto logConfigNode = clusterNode["LogConfig"]; + if(!logConfigNode["EnableLog"].isNull()) + cluster_.logConfig.enableLog = logConfigNode["EnableLog"].asString() == "true"; + if(!logConfigNode["LogProject"].isNull()) + cluster_.logConfig.logProject = logConfigNode["LogProject"].asString(); + if(!logConfigNode["LogStoreTTL"].isNull()) + cluster_.logConfig.logStoreTTL = logConfigNode["LogStoreTTL"].asString(); + auto workflowConfigNode = clusterNode["WorkflowConfig"]; + if(!workflowConfigNode["ArgoServerEnabled"].isNull()) + cluster_.workflowConfig.argoServerEnabled = workflowConfigNode["ArgoServerEnabled"].asString() == "true"; + if(!workflowConfigNode["WorkflowScheduleMode"].isNull()) + cluster_.workflowConfig.workflowScheduleMode = workflowConfigNode["WorkflowScheduleMode"].asString(); + if(!workflowConfigNode["PriceLimit"].isNull()) + cluster_.workflowConfig.priceLimit = workflowConfigNode["PriceLimit"].asString(); + auto allWorkflowUnitsNode = workflowConfigNode["WorkflowUnits"]["WorkflowUnit"]; + for (auto workflowConfigNodeWorkflowUnitsWorkflowUnit : allWorkflowUnitsNode) + { + Cluster::WorkflowConfig::WorkflowUnit workflowUnitObject; + if(!workflowConfigNodeWorkflowUnitsWorkflowUnit["RegionId"].isNull()) + workflowUnitObject.regionId = workflowConfigNodeWorkflowUnitsWorkflowUnit["RegionId"].asString(); + if(!workflowConfigNodeWorkflowUnitsWorkflowUnit["VpcId"].isNull()) + workflowUnitObject.vpcId = workflowConfigNodeWorkflowUnitsWorkflowUnit["VpcId"].asString(); + auto allVSwitches1Node = workflowConfigNodeWorkflowUnitsWorkflowUnit["VSwitches"]["VSwitch"]; + for (auto workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch : allVSwitches1Node) + { + Cluster::WorkflowConfig::WorkflowUnit::VSwitch vSwitches1Object; + if(!workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["VswitchId"].isNull()) + vSwitches1Object.vswitchId = workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["VswitchId"].asString(); + if(!workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["ZoneId"].isNull()) + vSwitches1Object.zoneId = workflowConfigNodeWorkflowUnitsWorkflowUnitVSwitchesVSwitch["ZoneId"].asString(); + workflowUnitObject.vSwitches1.push_back(vSwitches1Object); + } + cluster_.workflowConfig.workflowUnits.push_back(workflowUnitObject); + } + +} + +DescribeHubClusterDetailsResult::Cluster DescribeHubClusterDetailsResult::getCluster()const +{ + return cluster_; +} + diff --git a/adcp/src/model/DescribeHubClusterKubeconfigRequest.cc b/adcp/src/model/DescribeHubClusterKubeconfigRequest.cc new file mode 100644 index 000000000..8a001b98c --- /dev/null +++ b/adcp/src/model/DescribeHubClusterKubeconfigRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Adcp::Model::DescribeHubClusterKubeconfigRequest; + +DescribeHubClusterKubeconfigRequest::DescribeHubClusterKubeconfigRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusterKubeconfig") { + setMethod(HttpRequest::Method::Post); +} + +DescribeHubClusterKubeconfigRequest::~DescribeHubClusterKubeconfigRequest() {} + +std::string DescribeHubClusterKubeconfigRequest::getClusterId() const { + return clusterId_; +} + +void DescribeHubClusterKubeconfigRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +bool DescribeHubClusterKubeconfigRequest::getPrivateIpAddress() const { + return privateIpAddress_; +} + +void DescribeHubClusterKubeconfigRequest::setPrivateIpAddress(bool privateIpAddress) { + privateIpAddress_ = privateIpAddress; + setParameter(std::string("PrivateIpAddress"), privateIpAddress ? "true" : "false"); +} + diff --git a/adcp/src/model/DescribeHubClusterKubeconfigResult.cc b/adcp/src/model/DescribeHubClusterKubeconfigResult.cc new file mode 100644 index 000000000..d684718a4 --- /dev/null +++ b/adcp/src/model/DescribeHubClusterKubeconfigResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribeHubClusterKubeconfigResult::DescribeHubClusterKubeconfigResult() : + ServiceResult() +{} + +DescribeHubClusterKubeconfigResult::DescribeHubClusterKubeconfigResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeHubClusterKubeconfigResult::~DescribeHubClusterKubeconfigResult() +{} + +void DescribeHubClusterKubeconfigResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Kubeconfig"].isNull()) + kubeconfig_ = value["Kubeconfig"].asString(); + +} + +std::string DescribeHubClusterKubeconfigResult::getKubeconfig()const +{ + return kubeconfig_; +} + diff --git a/adcp/src/model/DescribeHubClusterLogsRequest.cc b/adcp/src/model/DescribeHubClusterLogsRequest.cc new file mode 100644 index 000000000..58f37625b --- /dev/null +++ b/adcp/src/model/DescribeHubClusterLogsRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribeHubClusterLogsRequest; + +DescribeHubClusterLogsRequest::DescribeHubClusterLogsRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusterLogs") { + setMethod(HttpRequest::Method::Post); +} + +DescribeHubClusterLogsRequest::~DescribeHubClusterLogsRequest() {} + +std::string DescribeHubClusterLogsRequest::getClusterId() const { + return clusterId_; +} + +void DescribeHubClusterLogsRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + diff --git a/adcp/src/model/DescribeHubClusterLogsResult.cc b/adcp/src/model/DescribeHubClusterLogsResult.cc new file mode 100644 index 000000000..53bf0e566 --- /dev/null +++ b/adcp/src/model/DescribeHubClusterLogsResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribeHubClusterLogsResult::DescribeHubClusterLogsResult() : + ServiceResult() +{} + +DescribeHubClusterLogsResult::DescribeHubClusterLogsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeHubClusterLogsResult::~DescribeHubClusterLogsResult() +{} + +void DescribeHubClusterLogsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allLogsNode = value["Logs"]["Log"]; + for (auto valueLogsLog : allLogsNode) + { + Log logsObject; + if(!valueLogsLog["CreationTime"].isNull()) + logsObject.creationTime = valueLogsLog["CreationTime"].asString(); + if(!valueLogsLog["ClusterId"].isNull()) + logsObject.clusterId = valueLogsLog["ClusterId"].asString(); + if(!valueLogsLog["ClusterLog"].isNull()) + logsObject.clusterLog = valueLogsLog["ClusterLog"].asString(); + if(!valueLogsLog["LogLevel"].isNull()) + logsObject.logLevel = valueLogsLog["LogLevel"].asString(); + logs_.push_back(logsObject); + } + +} + +std::vector DescribeHubClusterLogsResult::getLogs()const +{ + return logs_; +} + diff --git a/adcp/src/model/DescribeHubClustersRequest.cc b/adcp/src/model/DescribeHubClustersRequest.cc new file mode 100644 index 000000000..be0a82180 --- /dev/null +++ b/adcp/src/model/DescribeHubClustersRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribeHubClustersRequest; + +DescribeHubClustersRequest::DescribeHubClustersRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeHubClusters") { + setMethod(HttpRequest::Method::Post); +} + +DescribeHubClustersRequest::~DescribeHubClustersRequest() {} + +std::string DescribeHubClustersRequest::getProfile() const { + return profile_; +} + +void DescribeHubClustersRequest::setProfile(const std::string &profile) { + profile_ = profile; + setParameter(std::string("Profile"), profile); +} + diff --git a/adcp/src/model/DescribeHubClustersResult.cc b/adcp/src/model/DescribeHubClustersResult.cc new file mode 100644 index 000000000..088f76d88 --- /dev/null +++ b/adcp/src/model/DescribeHubClustersResult.cc @@ -0,0 +1,125 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribeHubClustersResult::DescribeHubClustersResult() : + ServiceResult() +{} + +DescribeHubClustersResult::DescribeHubClustersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeHubClustersResult::~DescribeHubClustersResult() +{} + +void DescribeHubClustersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allClustersNode = value["Clusters"]["Cluster"]; + for (auto valueClustersCluster : allClustersNode) + { + Cluster clustersObject; + auto allConditionsNode = valueClustersCluster["Conditions"]["Condition"]; + for (auto valueClustersClusterConditionsCondition : allConditionsNode) + { + Cluster::Condition conditionsObject; + if(!valueClustersClusterConditionsCondition["Type"].isNull()) + conditionsObject.type = valueClustersClusterConditionsCondition["Type"].asString(); + if(!valueClustersClusterConditionsCondition["Status"].isNull()) + conditionsObject.status = valueClustersClusterConditionsCondition["Status"].asString(); + if(!valueClustersClusterConditionsCondition["Reason"].isNull()) + conditionsObject.reason = valueClustersClusterConditionsCondition["Reason"].asString(); + if(!valueClustersClusterConditionsCondition["Message"].isNull()) + conditionsObject.message = valueClustersClusterConditionsCondition["Message"].asString(); + clustersObject.conditions.push_back(conditionsObject); + } + auto endpointsNode = value["Endpoints"]; + if(!endpointsNode["IntranetApiServerEndpoint"].isNull()) + clustersObject.endpoints.intranetApiServerEndpoint = endpointsNode["IntranetApiServerEndpoint"].asString(); + if(!endpointsNode["PublicApiServerEndpoint"].isNull()) + clustersObject.endpoints.publicApiServerEndpoint = endpointsNode["PublicApiServerEndpoint"].asString(); + auto clusterInfoNode = value["ClusterInfo"]; + if(!clusterInfoNode["Profile"].isNull()) + clustersObject.clusterInfo.profile = clusterInfoNode["Profile"].asString(); + if(!clusterInfoNode["CreationTime"].isNull()) + clustersObject.clusterInfo.creationTime = clusterInfoNode["CreationTime"].asString(); + if(!clusterInfoNode["UpdateTime"].isNull()) + clustersObject.clusterInfo.updateTime = clusterInfoNode["UpdateTime"].asString(); + if(!clusterInfoNode["ErrorMessage"].isNull()) + clustersObject.clusterInfo.errorMessage = clusterInfoNode["ErrorMessage"].asString(); + if(!clusterInfoNode["Version"].isNull()) + clustersObject.clusterInfo.version = clusterInfoNode["Version"].asString(); + if(!clusterInfoNode["State"].isNull()) + clustersObject.clusterInfo.state = clusterInfoNode["State"].asString(); + if(!clusterInfoNode["ClusterId"].isNull()) + clustersObject.clusterInfo.clusterId = clusterInfoNode["ClusterId"].asString(); + if(!clusterInfoNode["Name"].isNull()) + clustersObject.clusterInfo.name = clusterInfoNode["Name"].asString(); + if(!clusterInfoNode["RegionId"].isNull()) + clustersObject.clusterInfo.regionId = clusterInfoNode["RegionId"].asString(); + if(!clusterInfoNode["ClusterSpec"].isNull()) + clustersObject.clusterInfo.clusterSpec = clusterInfoNode["ClusterSpec"].asString(); + auto networkNode = value["Network"]; + if(!networkNode["VpcId"].isNull()) + clustersObject.network.vpcId = networkNode["VpcId"].asString(); + if(!networkNode["ClusterDomain"].isNull()) + clustersObject.network.clusterDomain = networkNode["ClusterDomain"].asString(); + auto allVSwitches = networkNode["VSwitches"]["VSwitches"]; + for (auto value : allVSwitches) + clustersObject.network.vSwitches.push_back(value.asString()); + auto allSecurityGroupIDs = networkNode["SecurityGroupIDs"]["SecurityGroupIDs"]; + for (auto value : allSecurityGroupIDs) + clustersObject.network.securityGroupIDs.push_back(value.asString()); + auto apiServerNode = value["ApiServer"]; + if(!apiServerNode["EnabledPublic"].isNull()) + clustersObject.apiServer.enabledPublic = apiServerNode["EnabledPublic"].asString() == "true"; + if(!apiServerNode["LoadBalancerId"].isNull()) + clustersObject.apiServer.loadBalancerId = apiServerNode["LoadBalancerId"].asString(); + if(!apiServerNode["ApiServerEipId"].isNull()) + clustersObject.apiServer.apiServerEipId = apiServerNode["ApiServerEipId"].asString(); + auto meshConfigNode = value["MeshConfig"]; + if(!meshConfigNode["EnableMesh"].isNull()) + clustersObject.meshConfig.enableMesh = meshConfigNode["EnableMesh"].asString() == "true"; + if(!meshConfigNode["MeshId"].isNull()) + clustersObject.meshConfig.meshId = meshConfigNode["MeshId"].asString(); + auto logConfigNode = value["LogConfig"]; + if(!logConfigNode["EnableLog"].isNull()) + clustersObject.logConfig.enableLog = logConfigNode["EnableLog"].asString() == "true"; + if(!logConfigNode["LogProject"].isNull()) + clustersObject.logConfig.logProject = logConfigNode["LogProject"].asString(); + if(!logConfigNode["LogStoreTTL"].isNull()) + clustersObject.logConfig.logStoreTTL = logConfigNode["LogStoreTTL"].asString(); + clusters_.push_back(clustersObject); + } + +} + +std::vector DescribeHubClustersResult::getClusters()const +{ + return clusters_; +} + diff --git a/adcp/src/model/DescribeManagedClustersRequest.cc b/adcp/src/model/DescribeManagedClustersRequest.cc new file mode 100644 index 000000000..5a2a4b8b7 --- /dev/null +++ b/adcp/src/model/DescribeManagedClustersRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribeManagedClustersRequest; + +DescribeManagedClustersRequest::DescribeManagedClustersRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeManagedClusters") { + setMethod(HttpRequest::Method::Post); +} + +DescribeManagedClustersRequest::~DescribeManagedClustersRequest() {} + +std::string DescribeManagedClustersRequest::getClusterId() const { + return clusterId_; +} + +void DescribeManagedClustersRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + diff --git a/adcp/src/model/DescribeManagedClustersResult.cc b/adcp/src/model/DescribeManagedClustersResult.cc new file mode 100644 index 000000000..b5f7222d9 --- /dev/null +++ b/adcp/src/model/DescribeManagedClustersResult.cc @@ -0,0 +1,92 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribeManagedClustersResult::DescribeManagedClustersResult() : + ServiceResult() +{} + +DescribeManagedClustersResult::DescribeManagedClustersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeManagedClustersResult::~DescribeManagedClustersResult() +{} + +void DescribeManagedClustersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allClustersNode = value["Clusters"]["Cluster"]; + for (auto valueClustersCluster : allClustersNode) + { + Cluster clustersObject; + auto cluster1Node = value["Cluster"]; + if(!cluster1Node["Name"].isNull()) + clustersObject.cluster1.name = cluster1Node["Name"].asString(); + if(!cluster1Node["ClusterID"].isNull()) + clustersObject.cluster1.clusterID = cluster1Node["ClusterID"].asString(); + if(!cluster1Node["Region"].isNull()) + clustersObject.cluster1.region = cluster1Node["Region"].asString(); + if(!cluster1Node["State"].isNull()) + clustersObject.cluster1.state = cluster1Node["State"].asString(); + if(!cluster1Node["ClusterType"].isNull()) + clustersObject.cluster1.clusterType = cluster1Node["ClusterType"].asString(); + if(!cluster1Node["Created"].isNull()) + clustersObject.cluster1.created = cluster1Node["Created"].asString(); + if(!cluster1Node["Updated"].isNull()) + clustersObject.cluster1.updated = cluster1Node["Updated"].asString(); + if(!cluster1Node["InitVersion"].isNull()) + clustersObject.cluster1.initVersion = cluster1Node["InitVersion"].asString(); + if(!cluster1Node["CurrentVersion"].isNull()) + clustersObject.cluster1.currentVersion = cluster1Node["CurrentVersion"].asString(); + if(!cluster1Node["ResourceGroupId"].isNull()) + clustersObject.cluster1.resourceGroupId = cluster1Node["ResourceGroupId"].asString(); + if(!cluster1Node["VpcID"].isNull()) + clustersObject.cluster1.vpcID = cluster1Node["VpcID"].asString(); + if(!cluster1Node["VSwitchID"].isNull()) + clustersObject.cluster1.vSwitchID = cluster1Node["VSwitchID"].asString(); + if(!cluster1Node["Profile"].isNull()) + clustersObject.cluster1.profile = cluster1Node["Profile"].asString(); + if(!cluster1Node["ClusterSpec"].isNull()) + clustersObject.cluster1.clusterSpec = cluster1Node["ClusterSpec"].asString(); + auto statusNode = value["Status"]; + if(!statusNode["State"].isNull()) + clustersObject.status.state = statusNode["State"].asString(); + if(!statusNode["Message"].isNull()) + clustersObject.status.message = statusNode["Message"].asString(); + auto meshStatusNode = value["MeshStatus"]; + if(!meshStatusNode["InMesh"].isNull()) + clustersObject.meshStatus.inMesh = meshStatusNode["InMesh"].asString() == "true"; + clusters_.push_back(clustersObject); + } + +} + +std::vector DescribeManagedClustersResult::getClusters()const +{ + return clusters_; +} + diff --git a/adcp/src/model/DescribePoliciesRequest.cc b/adcp/src/model/DescribePoliciesRequest.cc new file mode 100644 index 000000000..2caeb85e5 --- /dev/null +++ b/adcp/src/model/DescribePoliciesRequest.cc @@ -0,0 +1,27 @@ +/* + * 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::Adcp::Model::DescribePoliciesRequest; + +DescribePoliciesRequest::DescribePoliciesRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicies") { + setMethod(HttpRequest::Method::Post); +} + +DescribePoliciesRequest::~DescribePoliciesRequest() {} + diff --git a/adcp/src/model/DescribePoliciesResult.cc b/adcp/src/model/DescribePoliciesResult.cc new file mode 100644 index 000000000..6cf1aabca --- /dev/null +++ b/adcp/src/model/DescribePoliciesResult.cc @@ -0,0 +1,60 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribePoliciesResult::DescribePoliciesResult() : + ServiceResult() +{} + +DescribePoliciesResult::DescribePoliciesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribePoliciesResult::~DescribePoliciesResult() +{} + +void DescribePoliciesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allPoliciesNode = value["Policies"]["policy"]; + for (auto valuePoliciespolicy : allPoliciesNode) + { + Policy policiesObject; + if(!valuePoliciespolicy["Category"].isNull()) + policiesObject.category = valuePoliciespolicy["Category"].asString(); + auto allNames = value["Names"]["name"]; + for (auto value : allNames) + policiesObject.names.push_back(value.asString()); + policies_.push_back(policiesObject); + } + +} + +std::vector DescribePoliciesResult::getPolicies()const +{ + return policies_; +} + diff --git a/adcp/src/model/DescribePolicyDetailsRequest.cc b/adcp/src/model/DescribePolicyDetailsRequest.cc new file mode 100644 index 000000000..930ad2e58 --- /dev/null +++ b/adcp/src/model/DescribePolicyDetailsRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribePolicyDetailsRequest; + +DescribePolicyDetailsRequest::DescribePolicyDetailsRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicyDetails") { + setMethod(HttpRequest::Method::Post); +} + +DescribePolicyDetailsRequest::~DescribePolicyDetailsRequest() {} + +std::string DescribePolicyDetailsRequest::getPolicyName() const { + return policyName_; +} + +void DescribePolicyDetailsRequest::setPolicyName(const std::string &policyName) { + policyName_ = policyName; + setParameter(std::string("PolicyName"), policyName); +} + diff --git a/adcp/src/model/DescribePolicyDetailsResult.cc b/adcp/src/model/DescribePolicyDetailsResult.cc new file mode 100644 index 000000000..44ae6991d --- /dev/null +++ b/adcp/src/model/DescribePolicyDetailsResult.cc @@ -0,0 +1,68 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribePolicyDetailsResult::DescribePolicyDetailsResult() : + ServiceResult() +{} + +DescribePolicyDetailsResult::DescribePolicyDetailsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribePolicyDetailsResult::~DescribePolicyDetailsResult() +{} + +void DescribePolicyDetailsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto policyNode = value["Policy"]; + if(!policyNode["Name"].isNull()) + policy_.name = policyNode["Name"].asString(); + if(!policyNode["Category"].isNull()) + policy_.category = policyNode["Category"].asString(); + if(!policyNode["Description"].isNull()) + policy_.description = policyNode["Description"].asString(); + if(!policyNode["Action"].isNull()) + policy_.action = policyNode["Action"].asString(); + if(!policyNode["Severity"].isNull()) + policy_.severity = policyNode["Severity"].asString(); + if(!policyNode["Template"].isNull()) + policy_._template = policyNode["Template"].asString(); + if(!policyNode["NoConfig"].isNull()) + policy_.noConfig = std::stoi(policyNode["NoConfig"].asString()); + if(!policyNode["Created"].isNull()) + policy_.created = policyNode["Created"].asString(); + if(!policyNode["Updated"].isNull()) + policy_.updated = policyNode["Updated"].asString(); + +} + +DescribePolicyDetailsResult::Policy DescribePolicyDetailsResult::getPolicy()const +{ + return policy_; +} + diff --git a/adcp/src/model/DescribePolicyGovernanceInClusterRequest.cc b/adcp/src/model/DescribePolicyGovernanceInClusterRequest.cc new file mode 100644 index 000000000..67f69a449 --- /dev/null +++ b/adcp/src/model/DescribePolicyGovernanceInClusterRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribePolicyGovernanceInClusterRequest; + +DescribePolicyGovernanceInClusterRequest::DescribePolicyGovernanceInClusterRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicyGovernanceInCluster") { + setMethod(HttpRequest::Method::Post); +} + +DescribePolicyGovernanceInClusterRequest::~DescribePolicyGovernanceInClusterRequest() {} + +std::string DescribePolicyGovernanceInClusterRequest::getClusterId() const { + return clusterId_; +} + +void DescribePolicyGovernanceInClusterRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + diff --git a/adcp/src/model/DescribePolicyGovernanceInClusterResult.cc b/adcp/src/model/DescribePolicyGovernanceInClusterResult.cc new file mode 100644 index 000000000..b5194c9b1 --- /dev/null +++ b/adcp/src/model/DescribePolicyGovernanceInClusterResult.cc @@ -0,0 +1,146 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribePolicyGovernanceInClusterResult::DescribePolicyGovernanceInClusterResult() : + ServiceResult() +{} + +DescribePolicyGovernanceInClusterResult::DescribePolicyGovernanceInClusterResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribePolicyGovernanceInClusterResult::~DescribePolicyGovernanceInClusterResult() +{} + +void DescribePolicyGovernanceInClusterResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allPolicyGovernancesNode = value["PolicyGovernances"]["PolicyGovernance"]; + for (auto valuePolicyGovernancesPolicyGovernance : allPolicyGovernancesNode) + { + PolicyGovernance policyGovernancesObject; + auto clusterNode = value["Cluster"]; + if(!clusterNode["ClusterId"].isNull()) + policyGovernancesObject.cluster.clusterId = clusterNode["ClusterId"].asString(); + if(!clusterNode["Name"].isNull()) + policyGovernancesObject.cluster.name = clusterNode["Name"].asString(); + if(!clusterNode["RegionId"].isNull()) + policyGovernancesObject.cluster.regionId = clusterNode["RegionId"].asString(); + if(!clusterNode["State"].isNull()) + policyGovernancesObject.cluster.state = clusterNode["State"].asString(); + if(!clusterNode["ClusterType"].isNull()) + policyGovernancesObject.cluster.clusterType = clusterNode["ClusterType"].asString(); + if(!clusterNode["ClusterSpec"].isNull()) + policyGovernancesObject.cluster.clusterSpec = clusterNode["ClusterSpec"].asString(); + if(!clusterNode["Profile"].isNull()) + policyGovernancesObject.cluster.profile = clusterNode["Profile"].asString(); + auto policyGovernance1Node = value["PolicyGovernance"]; + auto allOnStateNode = policyGovernance1Node["OnState"]["State"]; + for (auto policyGovernance1NodeOnStateState : allOnStateNode) + { + PolicyGovernance::PolicyGovernance1::State stateObject; + if(!policyGovernance1NodeOnStateState["EnabledCount"].isNull()) + stateObject.enabledCount = std::stol(policyGovernance1NodeOnStateState["EnabledCount"].asString()); + if(!policyGovernance1NodeOnStateState["TotalCount"].isNull()) + stateObject.totalCount = std::stol(policyGovernance1NodeOnStateState["TotalCount"].asString()); + if(!policyGovernance1NodeOnStateState["Severity"].isNull()) + stateObject.severity = policyGovernance1NodeOnStateState["Severity"].asString(); + policyGovernancesObject.policyGovernance1.onState.push_back(stateObject); + } + auto admitLogNode = policyGovernance1Node["AdmitLog"]; + if(!admitLogNode["Progress"].isNull()) + policyGovernancesObject.policyGovernance1.admitLog.progress = admitLogNode["Progress"].asString(); + if(!admitLogNode["Count"].isNull()) + policyGovernancesObject.policyGovernance1.admitLog.count = admitLogNode["Count"].asString(); + if(!admitLogNode["LogProject"].isNull()) + policyGovernancesObject.policyGovernance1.admitLog.logProject = admitLogNode["LogProject"].asString(); + if(!admitLogNode["LogStore"].isNull()) + policyGovernancesObject.policyGovernance1.admitLog.logStore = admitLogNode["LogStore"].asString(); + auto allLogs = admitLogNode["Logs"]["Log"]; + for (auto value : allLogs) + policyGovernancesObject.policyGovernance1.admitLog.logs.push_back(value.asString()); + auto violationNode = policyGovernance1Node["Violation"]; + auto totalViolationsNode = violationNode["TotalViolations"]; + auto allDenyNode = totalViolationsNode["Deny"]["DenySeverity"]; + for (auto totalViolationsNodeDenyDenySeverity : allDenyNode) + { + PolicyGovernance::PolicyGovernance1::Violation::TotalViolations::DenySeverity denySeverityObject; + if(!totalViolationsNodeDenyDenySeverity["Severity"].isNull()) + denySeverityObject.severity = totalViolationsNodeDenyDenySeverity["Severity"].asString(); + if(!totalViolationsNodeDenyDenySeverity["Violations"].isNull()) + denySeverityObject.violations = std::stol(totalViolationsNodeDenyDenySeverity["Violations"].asString()); + policyGovernancesObject.policyGovernance1.violation.totalViolations.deny.push_back(denySeverityObject); + } + auto allWarnNode = totalViolationsNode["Warn"]["WarnSeverity"]; + for (auto totalViolationsNodeWarnWarnSeverity : allWarnNode) + { + PolicyGovernance::PolicyGovernance1::Violation::TotalViolations::WarnSeverity warnSeverityObject; + if(!totalViolationsNodeWarnWarnSeverity["Severity"].isNull()) + warnSeverityObject.severity = totalViolationsNodeWarnWarnSeverity["Severity"].asString(); + if(!totalViolationsNodeWarnWarnSeverity["Violations"].isNull()) + warnSeverityObject.violations = totalViolationsNodeWarnWarnSeverity["Violations"].asString(); + policyGovernancesObject.policyGovernance1.violation.totalViolations.warn.push_back(warnSeverityObject); + } + auto violationsNode = violationNode["Violations"]; + auto allDeny2Node = violationsNode["Deny"]["DenyViolations"]; + for (auto violationsNodeDenyDenyViolations : allDeny2Node) + { + PolicyGovernance::PolicyGovernance1::Violation::Violations::DenyViolations denyViolationsObject; + if(!violationsNodeDenyDenyViolations["PolicyName"].isNull()) + denyViolationsObject.policyName = violationsNodeDenyDenyViolations["PolicyName"].asString(); + if(!violationsNodeDenyDenyViolations["PolicyDescription"].isNull()) + denyViolationsObject.policyDescription = violationsNodeDenyDenyViolations["PolicyDescription"].asString(); + if(!violationsNodeDenyDenyViolations["Severity"].isNull()) + denyViolationsObject.severity = violationsNodeDenyDenyViolations["Severity"].asString(); + if(!violationsNodeDenyDenyViolations["Violations"].isNull()) + denyViolationsObject.violations = std::stol(violationsNodeDenyDenyViolations["Violations"].asString()); + policyGovernancesObject.policyGovernance1.violation.violations.deny2.push_back(denyViolationsObject); + } + auto allWarn3Node = violationsNode["Warn"]["WarnViolations"]; + for (auto violationsNodeWarnWarnViolations : allWarn3Node) + { + PolicyGovernance::PolicyGovernance1::Violation::Violations::WarnViolations warnViolationsObject; + if(!violationsNodeWarnWarnViolations["PolicyName"].isNull()) + warnViolationsObject.policyName = violationsNodeWarnWarnViolations["PolicyName"].asString(); + if(!violationsNodeWarnWarnViolations["PolicyDescription"].isNull()) + warnViolationsObject.policyDescription = violationsNodeWarnWarnViolations["PolicyDescription"].asString(); + if(!violationsNodeWarnWarnViolations["Severity"].isNull()) + warnViolationsObject.severity = violationsNodeWarnWarnViolations["Severity"].asString(); + if(!violationsNodeWarnWarnViolations["Violations"].isNull()) + warnViolationsObject.violations = std::stol(violationsNodeWarnWarnViolations["Violations"].asString()); + policyGovernancesObject.policyGovernance1.violation.violations.warn3.push_back(warnViolationsObject); + } + policyGovernances_.push_back(policyGovernancesObject); + } + +} + +std::vector DescribePolicyGovernanceInClusterResult::getPolicyGovernances()const +{ + return policyGovernances_; +} + diff --git a/adcp/src/model/DescribePolicyInstancesRequest.cc b/adcp/src/model/DescribePolicyInstancesRequest.cc new file mode 100644 index 000000000..872b85389 --- /dev/null +++ b/adcp/src/model/DescribePolicyInstancesRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Adcp::Model::DescribePolicyInstancesRequest; + +DescribePolicyInstancesRequest::DescribePolicyInstancesRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicyInstances") { + setMethod(HttpRequest::Method::Post); +} + +DescribePolicyInstancesRequest::~DescribePolicyInstancesRequest() {} + +std::string DescribePolicyInstancesRequest::getClusterId() const { + return clusterId_; +} + +void DescribePolicyInstancesRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string DescribePolicyInstancesRequest::getPolicyName() const { + return policyName_; +} + +void DescribePolicyInstancesRequest::setPolicyName(const std::string &policyName) { + policyName_ = policyName; + setParameter(std::string("PolicyName"), policyName); +} + diff --git a/adcp/src/model/DescribePolicyInstancesResult.cc b/adcp/src/model/DescribePolicyInstancesResult.cc new file mode 100644 index 000000000..d9ff7d66d --- /dev/null +++ b/adcp/src/model/DescribePolicyInstancesResult.cc @@ -0,0 +1,75 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribePolicyInstancesResult::DescribePolicyInstancesResult() : + ServiceResult() +{} + +DescribePolicyInstancesResult::DescribePolicyInstancesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribePolicyInstancesResult::~DescribePolicyInstancesResult() +{} + +void DescribePolicyInstancesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allPoliciesNode = value["Policies"]["Policy"]; + for (auto valuePoliciesPolicy : allPoliciesNode) + { + Policy policiesObject; + if(!valuePoliciesPolicy["PolicyName"].isNull()) + policiesObject.policyName = valuePoliciesPolicy["PolicyName"].asString(); + if(!valuePoliciesPolicy["InstanceName"].isNull()) + policiesObject.instanceName = valuePoliciesPolicy["InstanceName"].asString(); + if(!valuePoliciesPolicy["PolicyCategory"].isNull()) + policiesObject.policyCategory = valuePoliciesPolicy["PolicyCategory"].asString(); + if(!valuePoliciesPolicy["PolicyDescription"].isNull()) + policiesObject.policyDescription = valuePoliciesPolicy["PolicyDescription"].asString(); + if(!valuePoliciesPolicy["PolicySeverity"].isNull()) + policiesObject.policySeverity = valuePoliciesPolicy["PolicySeverity"].asString(); + if(!valuePoliciesPolicy["PolicyScope"].isNull()) + policiesObject.policyScope = valuePoliciesPolicy["PolicyScope"].asString(); + if(!valuePoliciesPolicy["PolicyAction"].isNull()) + policiesObject.policyAction = valuePoliciesPolicy["PolicyAction"].asString(); + if(!valuePoliciesPolicy["TotalViolations"].isNull()) + policiesObject.totalViolations = std::stol(valuePoliciesPolicy["TotalViolations"].asString()); + if(!valuePoliciesPolicy["ClusterId"].isNull()) + policiesObject.clusterId = valuePoliciesPolicy["ClusterId"].asString(); + if(!valuePoliciesPolicy["PolicyParameters"].isNull()) + policiesObject.policyParameters = valuePoliciesPolicy["PolicyParameters"].asString(); + policies_.push_back(policiesObject); + } + +} + +std::vector DescribePolicyInstancesResult::getPolicies()const +{ + return policies_; +} + diff --git a/adcp/src/model/DescribePolicyInstancesStatusRequest.cc b/adcp/src/model/DescribePolicyInstancesStatusRequest.cc new file mode 100644 index 000000000..b3bc17732 --- /dev/null +++ b/adcp/src/model/DescribePolicyInstancesStatusRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribePolicyInstancesStatusRequest; + +DescribePolicyInstancesStatusRequest::DescribePolicyInstancesStatusRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribePolicyInstancesStatus") { + setMethod(HttpRequest::Method::Post); +} + +DescribePolicyInstancesStatusRequest::~DescribePolicyInstancesStatusRequest() {} + +std::string DescribePolicyInstancesStatusRequest::getClusterId() const { + return clusterId_; +} + +void DescribePolicyInstancesStatusRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + diff --git a/adcp/src/model/DescribePolicyInstancesStatusResult.cc b/adcp/src/model/DescribePolicyInstancesStatusResult.cc new file mode 100644 index 000000000..7df84ef3b --- /dev/null +++ b/adcp/src/model/DescribePolicyInstancesStatusResult.cc @@ -0,0 +1,86 @@ +/* + * 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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribePolicyInstancesStatusResult::DescribePolicyInstancesStatusResult() : + ServiceResult() +{} + +DescribePolicyInstancesStatusResult::DescribePolicyInstancesStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribePolicyInstancesStatusResult::~DescribePolicyInstancesStatusResult() +{} + +void DescribePolicyInstancesStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto policiesNode = value["Policies"]; + auto allPolicyInstancesNode = policiesNode["PolicyInstances"]["PolicyInstance"]; + for (auto policiesNodePolicyInstancesPolicyInstance : allPolicyInstancesNode) + { + Policies::PolicyInstance policyInstanceObject; + if(!policiesNodePolicyInstancesPolicyInstance["PolicyName"].isNull()) + policyInstanceObject.policyName = policiesNodePolicyInstancesPolicyInstance["PolicyName"].asString(); + if(!policiesNodePolicyInstancesPolicyInstance["PolicyCategory"].isNull()) + policyInstanceObject.policyCategory = policiesNodePolicyInstancesPolicyInstance["PolicyCategory"].asString(); + if(!policiesNodePolicyInstancesPolicyInstance["PolicyDescription"].isNull()) + policyInstanceObject.policyDescription = policiesNodePolicyInstancesPolicyInstance["PolicyDescription"].asString(); + if(!policiesNodePolicyInstancesPolicyInstance["PolicySeverity"].isNull()) + policyInstanceObject.policySeverity = policiesNodePolicyInstancesPolicyInstance["PolicySeverity"].asString(); + if(!policiesNodePolicyInstancesPolicyInstance["PolicyInstancesCount"].isNull()) + policyInstanceObject.policyInstancesCount = std::stol(policiesNodePolicyInstancesPolicyInstance["PolicyInstancesCount"].asString()); + auto allPolicyClustersNode = policiesNodePolicyInstancesPolicyInstance["PolicyClusters"]["PolicyCluster"]; + for (auto policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster : allPolicyClustersNode) + { + Policies::PolicyInstance::PolicyCluster policyClustersObject; + if(!policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["ClusterId"].isNull()) + policyClustersObject.clusterId = policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["ClusterId"].asString(); + if(!policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["Status"].isNull()) + policyClustersObject.status = policiesNodePolicyInstancesPolicyInstancePolicyClustersPolicyCluster["Status"].asString(); + policyInstanceObject.policyClusters.push_back(policyClustersObject); + } + policies_.policyInstances.push_back(policyInstanceObject); + } + auto allSeverityInfoNode = policiesNode["SeverityInfo"]["SeverityInfoItem"]; + for (auto policiesNodeSeverityInfoSeverityInfoItem : allSeverityInfoNode) + { + Policies::SeverityInfoItem severityInfoItemObject; + if(!policiesNodeSeverityInfoSeverityInfoItem["SeverityType"].isNull()) + severityInfoItemObject.severityType = policiesNodeSeverityInfoSeverityInfoItem["SeverityType"].asString(); + if(!policiesNodeSeverityInfoSeverityInfoItem["SeverityCount"].isNull()) + severityInfoItemObject.severityCount = policiesNodeSeverityInfoSeverityInfoItem["SeverityCount"].asString(); + policies_.severityInfo.push_back(severityInfoItemObject); + } + +} + +DescribePolicyInstancesStatusResult::Policies DescribePolicyInstancesStatusResult::getPolicies()const +{ + return policies_; +} + diff --git a/adcp/src/model/DescribeRegionsRequest.cc b/adcp/src/model/DescribeRegionsRequest.cc new file mode 100644 index 000000000..9846cf12c --- /dev/null +++ b/adcp/src/model/DescribeRegionsRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribeRegionsRequest; + +DescribeRegionsRequest::DescribeRegionsRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeRegions") { + setMethod(HttpRequest::Method::Get); +} + +DescribeRegionsRequest::~DescribeRegionsRequest() {} + +std::string DescribeRegionsRequest::getLanguage() const { + return language_; +} + +void DescribeRegionsRequest::setLanguage(const std::string &language) { + language_ = language; + setParameter(std::string("Language"), language); +} + diff --git a/adcp/src/model/DescribeRegionsResult.cc b/adcp/src/model/DescribeRegionsResult.cc new file mode 100644 index 000000000..4d60e3f73 --- /dev/null +++ b/adcp/src/model/DescribeRegionsResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Adcp; +using namespace AlibabaCloud::Adcp::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["RegionEndpoint"].isNull()) + regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString(); + if(!valueRegionsRegion["RegionVpcEndpoint"].isNull()) + regionsObject.regionVpcEndpoint = valueRegionsRegion["RegionVpcEndpoint"].asString(); + if(!valueRegionsRegion["LocalName"].isNull()) + regionsObject.localName = valueRegionsRegion["LocalName"].asString(); + regions_.push_back(regionsObject); + } + +} + +std::vector DescribeRegionsResult::getRegions()const +{ + return regions_; +} + diff --git a/adcp/src/model/DescribeUserPermissionsRequest.cc b/adcp/src/model/DescribeUserPermissionsRequest.cc new file mode 100644 index 000000000..0a785acba --- /dev/null +++ b/adcp/src/model/DescribeUserPermissionsRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Adcp::Model::DescribeUserPermissionsRequest; + +DescribeUserPermissionsRequest::DescribeUserPermissionsRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DescribeUserPermissions") { + setMethod(HttpRequest::Method::Post); +} + +DescribeUserPermissionsRequest::~DescribeUserPermissionsRequest() {} + +std::string DescribeUserPermissionsRequest::getUserId() const { + return userId_; +} + +void DescribeUserPermissionsRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + diff --git a/adcp/src/model/DescribeUserPermissionsResult.cc b/adcp/src/model/DescribeUserPermissionsResult.cc new file mode 100644 index 000000000..43cd135ef --- /dev/null +++ b/adcp/src/model/DescribeUserPermissionsResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DescribeUserPermissionsResult::DescribeUserPermissionsResult() : + ServiceResult() +{} + +DescribeUserPermissionsResult::DescribeUserPermissionsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeUserPermissionsResult::~DescribeUserPermissionsResult() +{} + +void DescribeUserPermissionsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allPermissionsNode = value["Permissions"]["Permission"]; + for (auto valuePermissionsPermission : allPermissionsNode) + { + Permission permissionsObject; + if(!valuePermissionsPermission["RoleType"].isNull()) + permissionsObject.roleType = valuePermissionsPermission["RoleType"].asString(); + if(!valuePermissionsPermission["RoleName"].isNull()) + permissionsObject.roleName = valuePermissionsPermission["RoleName"].asString(); + if(!valuePermissionsPermission["ResourceType"].isNull()) + permissionsObject.resourceType = valuePermissionsPermission["ResourceType"].asString(); + if(!valuePermissionsPermission["ResourceId"].isNull()) + permissionsObject.resourceId = valuePermissionsPermission["ResourceId"].asString(); + permissions_.push_back(permissionsObject); + } + +} + +std::vector DescribeUserPermissionsResult::getPermissions()const +{ + return permissions_; +} + diff --git a/adcp/src/model/DetachClusterFromHubRequest.cc b/adcp/src/model/DetachClusterFromHubRequest.cc new file mode 100644 index 000000000..361b0f288 --- /dev/null +++ b/adcp/src/model/DetachClusterFromHubRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Adcp::Model::DetachClusterFromHubRequest; + +DetachClusterFromHubRequest::DetachClusterFromHubRequest() + : RpcServiceRequest("adcp", "2022-01-01", "DetachClusterFromHub") { + setMethod(HttpRequest::Method::Post); +} + +DetachClusterFromHubRequest::~DetachClusterFromHubRequest() {} + +bool DetachClusterFromHubRequest::getDetachFromMesh() const { + return detachFromMesh_; +} + +void DetachClusterFromHubRequest::setDetachFromMesh(bool detachFromMesh) { + detachFromMesh_ = detachFromMesh; + setParameter(std::string("DetachFromMesh"), detachFromMesh ? "true" : "false"); +} + +std::string DetachClusterFromHubRequest::getClusterId() const { + return clusterId_; +} + +void DetachClusterFromHubRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string DetachClusterFromHubRequest::getClusterIds() const { + return clusterIds_; +} + +void DetachClusterFromHubRequest::setClusterIds(const std::string &clusterIds) { + clusterIds_ = clusterIds; + setBodyParameter(std::string("ClusterIds"), clusterIds); +} + diff --git a/adcp/src/model/DetachClusterFromHubResult.cc b/adcp/src/model/DetachClusterFromHubResult.cc new file mode 100644 index 000000000..953d38a1e --- /dev/null +++ b/adcp/src/model/DetachClusterFromHubResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +DetachClusterFromHubResult::DetachClusterFromHubResult() : + ServiceResult() +{} + +DetachClusterFromHubResult::DetachClusterFromHubResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DetachClusterFromHubResult::~DetachClusterFromHubResult() +{} + +void DetachClusterFromHubResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allManagedClusterIds = value["ManagedClusterIds"]["ManagedClusterId"]; + for (const auto &item : allManagedClusterIds) + managedClusterIds_.push_back(item.asString()); + if(!value["ClusterId"].isNull()) + clusterId_ = value["ClusterId"].asString(); + if(!value["TaskId"].isNull()) + taskId_ = value["TaskId"].asString(); + +} + +std::string DetachClusterFromHubResult::getTaskId()const +{ + return taskId_; +} + +std::string DetachClusterFromHubResult::getClusterId()const +{ + return clusterId_; +} + +std::vector DetachClusterFromHubResult::getManagedClusterIds()const +{ + return managedClusterIds_; +} + diff --git a/adcp/src/model/GrantUserPermissionRequest.cc b/adcp/src/model/GrantUserPermissionRequest.cc new file mode 100644 index 000000000..e552b4515 --- /dev/null +++ b/adcp/src/model/GrantUserPermissionRequest.cc @@ -0,0 +1,81 @@ +/* + * 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::Adcp::Model::GrantUserPermissionRequest; + +GrantUserPermissionRequest::GrantUserPermissionRequest() + : RpcServiceRequest("adcp", "2022-01-01", "GrantUserPermission") { + setMethod(HttpRequest::Method::Post); +} + +GrantUserPermissionRequest::~GrantUserPermissionRequest() {} + +std::string GrantUserPermissionRequest::getUserId() const { + return userId_; +} + +void GrantUserPermissionRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +bool GrantUserPermissionRequest::getIsRamRole() const { + return isRamRole_; +} + +void GrantUserPermissionRequest::setIsRamRole(bool isRamRole) { + isRamRole_ = isRamRole; + setParameter(std::string("IsRamRole"), isRamRole ? "true" : "false"); +} + +std::string GrantUserPermissionRequest::getRoleType() const { + return roleType_; +} + +void GrantUserPermissionRequest::setRoleType(const std::string &roleType) { + roleType_ = roleType; + setParameter(std::string("RoleType"), roleType); +} + +std::string GrantUserPermissionRequest::getRoleName() const { + return roleName_; +} + +void GrantUserPermissionRequest::setRoleName(const std::string &roleName) { + roleName_ = roleName; + setParameter(std::string("RoleName"), roleName); +} + +std::string GrantUserPermissionRequest::getClusterId() const { + return clusterId_; +} + +void GrantUserPermissionRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string GrantUserPermissionRequest::get_Namespace() const { + return _namespace_; +} + +void GrantUserPermissionRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + diff --git a/adcp/src/model/GrantUserPermissionResult.cc b/adcp/src/model/GrantUserPermissionResult.cc new file mode 100644 index 000000000..fa423c9c7 --- /dev/null +++ b/adcp/src/model/GrantUserPermissionResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +GrantUserPermissionResult::GrantUserPermissionResult() : + ServiceResult() +{} + +GrantUserPermissionResult::GrantUserPermissionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GrantUserPermissionResult::~GrantUserPermissionResult() +{} + +void GrantUserPermissionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/adcp/src/model/GrantUserPermissionsRequest.cc b/adcp/src/model/GrantUserPermissionsRequest.cc new file mode 100644 index 000000000..ae70ae7b8 --- /dev/null +++ b/adcp/src/model/GrantUserPermissionsRequest.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::Adcp::Model::GrantUserPermissionsRequest; + +GrantUserPermissionsRequest::GrantUserPermissionsRequest() + : RpcServiceRequest("adcp", "2022-01-01", "GrantUserPermissions") { + setMethod(HttpRequest::Method::Post); +} + +GrantUserPermissionsRequest::~GrantUserPermissionsRequest() {} + +std::string GrantUserPermissionsRequest::getUserId() const { + return userId_; +} + +void GrantUserPermissionsRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::vector GrantUserPermissionsRequest::getPermissions() const { + return permissions_; +} + +void GrantUserPermissionsRequest::setPermissions(const std::vector &permissions) { + permissions_ = permissions; + for(int dep1 = 0; dep1 != permissions.size(); dep1++) { + setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".IsRamRole", permissions[dep1].isRamRole ? "true" : "false"); + setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".RoleName", permissions[dep1].roleName); + setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".Namespace", permissions[dep1]._namespace); + setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".RoleType", permissions[dep1].roleType); + setParameter(std::string("Permissions") + "." + std::to_string(dep1 + 1) + ".ClusterId", permissions[dep1].clusterId); + } +} + diff --git a/adcp/src/model/GrantUserPermissionsResult.cc b/adcp/src/model/GrantUserPermissionsResult.cc new file mode 100644 index 000000000..f7ed38cff --- /dev/null +++ b/adcp/src/model/GrantUserPermissionsResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +GrantUserPermissionsResult::GrantUserPermissionsResult() : + ServiceResult() +{} + +GrantUserPermissionsResult::GrantUserPermissionsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GrantUserPermissionsResult::~GrantUserPermissionsResult() +{} + +void GrantUserPermissionsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/adcp/src/model/UpdateHubClusterFeatureRequest.cc b/adcp/src/model/UpdateHubClusterFeatureRequest.cc new file mode 100644 index 000000000..8fc52a1e4 --- /dev/null +++ b/adcp/src/model/UpdateHubClusterFeatureRequest.cc @@ -0,0 +1,175 @@ +/* + * 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::Adcp::Model::UpdateHubClusterFeatureRequest; + +UpdateHubClusterFeatureRequest::UpdateHubClusterFeatureRequest() + : RpcServiceRequest("adcp", "2022-01-01", "UpdateHubClusterFeature") { + setMethod(HttpRequest::Method::Post); +} + +UpdateHubClusterFeatureRequest::~UpdateHubClusterFeatureRequest() {} + +std::vector UpdateHubClusterFeatureRequest::getAccessControlList() const { + return accessControlList_; +} + +void UpdateHubClusterFeatureRequest::setAccessControlList(const std::vector &accessControlList) { + accessControlList_ = accessControlList; + for(int dep1 = 0; dep1 != accessControlList.size(); dep1++) { + setParameter(std::string("AccessControlList") + "." + std::to_string(dep1 + 1), accessControlList[dep1]); + } +} + +bool UpdateHubClusterFeatureRequest::getMonitorEnabled() const { + return monitorEnabled_; +} + +void UpdateHubClusterFeatureRequest::setMonitorEnabled(bool monitorEnabled) { + monitorEnabled_ = monitorEnabled; + setParameter(std::string("MonitorEnabled"), monitorEnabled ? "true" : "false"); +} + +bool UpdateHubClusterFeatureRequest::getDeletionProtection() const { + return deletionProtection_; +} + +void UpdateHubClusterFeatureRequest::setDeletionProtection(bool deletionProtection) { + deletionProtection_ = deletionProtection; + setParameter(std::string("DeletionProtection"), deletionProtection ? "true" : "false"); +} + +bool UpdateHubClusterFeatureRequest::getEnableMesh() const { + return enableMesh_; +} + +void UpdateHubClusterFeatureRequest::setEnableMesh(bool enableMesh) { + enableMesh_ = enableMesh; + setParameter(std::string("EnableMesh"), enableMesh ? "true" : "false"); +} + +bool UpdateHubClusterFeatureRequest::getArgoCDHAEnabled() const { + return argoCDHAEnabled_; +} + +void UpdateHubClusterFeatureRequest::setArgoCDHAEnabled(bool argoCDHAEnabled) { + argoCDHAEnabled_ = argoCDHAEnabled; + setParameter(std::string("ArgoCDHAEnabled"), argoCDHAEnabled ? "true" : "false"); +} + +bool UpdateHubClusterFeatureRequest::getArgoCDEnabled() const { + return argoCDEnabled_; +} + +void UpdateHubClusterFeatureRequest::setArgoCDEnabled(bool argoCDEnabled) { + argoCDEnabled_ = argoCDEnabled; + setParameter(std::string("ArgoCDEnabled"), argoCDEnabled ? "true" : "false"); +} + +std::vector UpdateHubClusterFeatureRequest::getVSwitches() const { + return vSwitches_; +} + +void UpdateHubClusterFeatureRequest::setVSwitches(const std::vector &vSwitches) { + vSwitches_ = vSwitches; + for(int dep1 = 0; dep1 != vSwitches.size(); dep1++) { + setParameter(std::string("VSwitches") + "." + std::to_string(dep1 + 1), vSwitches[dep1]); + } +} + +std::string UpdateHubClusterFeatureRequest::getName() const { + return name_; +} + +void UpdateHubClusterFeatureRequest::setName(const std::string &name) { + name_ = name; + setParameter(std::string("Name"), name); +} + +bool UpdateHubClusterFeatureRequest::getPublicAccessEnabled() const { + return publicAccessEnabled_; +} + +void UpdateHubClusterFeatureRequest::setPublicAccessEnabled(bool publicAccessEnabled) { + publicAccessEnabled_ = publicAccessEnabled; + setParameter(std::string("PublicAccessEnabled"), publicAccessEnabled ? "true" : "false"); +} + +bool UpdateHubClusterFeatureRequest::getPublicApiServerEnabled() const { + return publicApiServerEnabled_; +} + +void UpdateHubClusterFeatureRequest::setPublicApiServerEnabled(bool publicApiServerEnabled) { + publicApiServerEnabled_ = publicApiServerEnabled; + setParameter(std::string("PublicApiServerEnabled"), publicApiServerEnabled ? "true" : "false"); +} + +bool UpdateHubClusterFeatureRequest::getArgoServerEnabled() const { + return argoServerEnabled_; +} + +void UpdateHubClusterFeatureRequest::setArgoServerEnabled(bool argoServerEnabled) { + argoServerEnabled_ = argoServerEnabled; + setParameter(std::string("ArgoServerEnabled"), argoServerEnabled ? "true" : "false"); +} + +std::string UpdateHubClusterFeatureRequest::getWorkflowScheduleMode() const { + return workflowScheduleMode_; +} + +void UpdateHubClusterFeatureRequest::setWorkflowScheduleMode(const std::string &workflowScheduleMode) { + workflowScheduleMode_ = workflowScheduleMode; + setParameter(std::string("WorkflowScheduleMode"), workflowScheduleMode); +} + +bool UpdateHubClusterFeatureRequest::getAuditLogEnabled() const { + return auditLogEnabled_; +} + +void UpdateHubClusterFeatureRequest::setAuditLogEnabled(bool auditLogEnabled) { + auditLogEnabled_ = auditLogEnabled; + setParameter(std::string("AuditLogEnabled"), auditLogEnabled ? "true" : "false"); +} + +std::string UpdateHubClusterFeatureRequest::getClusterId() const { + return clusterId_; +} + +void UpdateHubClusterFeatureRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string UpdateHubClusterFeatureRequest::getPriceLimit() const { + return priceLimit_; +} + +void UpdateHubClusterFeatureRequest::setPriceLimit(const std::string &priceLimit) { + priceLimit_ = priceLimit; + setParameter(std::string("PriceLimit"), priceLimit); +} + +std::string UpdateHubClusterFeatureRequest::getApiServerEipId() const { + return apiServerEipId_; +} + +void UpdateHubClusterFeatureRequest::setApiServerEipId(const std::string &apiServerEipId) { + apiServerEipId_ = apiServerEipId; + setParameter(std::string("ApiServerEipId"), apiServerEipId); +} + diff --git a/adcp/src/model/UpdateHubClusterFeatureResult.cc b/adcp/src/model/UpdateHubClusterFeatureResult.cc new file mode 100644 index 000000000..d6f79fe25 --- /dev/null +++ b/adcp/src/model/UpdateHubClusterFeatureResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +UpdateHubClusterFeatureResult::UpdateHubClusterFeatureResult() : + ServiceResult() +{} + +UpdateHubClusterFeatureResult::UpdateHubClusterFeatureResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateHubClusterFeatureResult::~UpdateHubClusterFeatureResult() +{} + +void UpdateHubClusterFeatureResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/adcp/src/model/UpdateUserPermissionRequest.cc b/adcp/src/model/UpdateUserPermissionRequest.cc new file mode 100644 index 000000000..5d74d0855 --- /dev/null +++ b/adcp/src/model/UpdateUserPermissionRequest.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Adcp::Model::UpdateUserPermissionRequest; + +UpdateUserPermissionRequest::UpdateUserPermissionRequest() + : RpcServiceRequest("adcp", "2022-01-01", "UpdateUserPermission") { + setMethod(HttpRequest::Method::Post); +} + +UpdateUserPermissionRequest::~UpdateUserPermissionRequest() {} + +std::string UpdateUserPermissionRequest::getUserId() const { + return userId_; +} + +void UpdateUserPermissionRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string UpdateUserPermissionRequest::getRoleType() const { + return roleType_; +} + +void UpdateUserPermissionRequest::setRoleType(const std::string &roleType) { + roleType_ = roleType; + setParameter(std::string("RoleType"), roleType); +} + +std::string UpdateUserPermissionRequest::getRoleName() const { + return roleName_; +} + +void UpdateUserPermissionRequest::setRoleName(const std::string &roleName) { + roleName_ = roleName; + setParameter(std::string("RoleName"), roleName); +} + +std::string UpdateUserPermissionRequest::getClusterId() const { + return clusterId_; +} + +void UpdateUserPermissionRequest::setClusterId(const std::string &clusterId) { + clusterId_ = clusterId; + setParameter(std::string("ClusterId"), clusterId); +} + +std::string UpdateUserPermissionRequest::get_Namespace() const { + return _namespace_; +} + +void UpdateUserPermissionRequest::set_Namespace(const std::string &_namespace) { + _namespace_ = _namespace; + setParameter(std::string("Namespace"), _namespace); +} + diff --git a/adcp/src/model/UpdateUserPermissionResult.cc b/adcp/src/model/UpdateUserPermissionResult.cc new file mode 100644 index 000000000..37cabc581 --- /dev/null +++ b/adcp/src/model/UpdateUserPermissionResult.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::Adcp; +using namespace AlibabaCloud::Adcp::Model; + +UpdateUserPermissionResult::UpdateUserPermissionResult() : + ServiceResult() +{} + +UpdateUserPermissionResult::UpdateUserPermissionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateUserPermissionResult::~UpdateUserPermissionResult() +{} + +void UpdateUserPermissionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} +