From cf984bbcfc834731332cd31126adffd1fd6c97ae Mon Sep 17 00:00:00 2001 From: sdk-team Date: Tue, 30 Nov 2021 02:41:43 +0000 Subject: [PATCH] Support health check paging. --- CHANGELOG | 3 + VERSION | 2 +- alb/CMakeLists.txt | 20 ++ alb/include/alibabacloud/alb/AlbClient.h | 40 ++++ .../model/AddServersToServerGroupRequest.h | 1 + ...yHealthCheckTemplateToServerGroupRequest.h | 51 +++++ ...lyHealthCheckTemplateToServerGroupResult.h | 51 +++++ ...monBandwidthPackageToLoadBalancerRequest.h | 54 ++++++ ...mmonBandwidthPackageToLoadBalancerResult.h | 51 +++++ .../alb/model/CreateLoadBalancerRequest.h | 5 + .../alb/model/CreateServerGroupRequest.h | 6 + ...nBandwidthPackageFromLoadBalancerRequest.h | 54 ++++++ ...onBandwidthPackageFromLoadBalancerResult.h | 51 +++++ .../model/GetListenerHealthStatusRequest.h | 51 +++++ .../alb/model/GetListenerHealthStatusResult.h | 109 +++++++++++ .../model/GetLoadBalancerAttributeResult.h | 39 ++-- .../alibabacloud/alb/model/ListAclsResult.h | 1 + .../alb/model/ListLoadBalancersRequest.h | 6 + .../alb/model/ListLoadBalancersResult.h | 3 + .../alb/model/ListServerGroupServersResult.h | 1 + .../alb/model/ListServerGroupsResult.h | 4 + .../ReplaceServersInServerGroupRequest.h | 1 + .../model/UpdateLoadBalancerZonesRequest.h | 56 ++++++ .../alb/model/UpdateLoadBalancerZonesResult.h | 51 +++++ .../model/UpdateServerGroupAttributeRequest.h | 3 + alb/src/AlbClient.cc | 180 ++++++++++++++++++ .../model/AddServersToServerGroupRequest.cc | 1 + ...HealthCheckTemplateToServerGroupRequest.cc | 63 ++++++ ...yHealthCheckTemplateToServerGroupResult.cc | 51 +++++ ...onBandwidthPackageToLoadBalancerRequest.cc | 72 +++++++ ...monBandwidthPackageToLoadBalancerResult.cc | 51 +++++ alb/src/model/CreateLoadBalancerRequest.cc | 11 ++ alb/src/model/CreateServerGroupRequest.cc | 18 ++ ...BandwidthPackageFromLoadBalancerRequest.cc | 72 +++++++ ...nBandwidthPackageFromLoadBalancerResult.cc | 51 +++++ .../model/GetListenerHealthStatusRequest.cc | 63 ++++++ .../model/GetListenerHealthStatusResult.cc | 147 ++++++++++++++ .../model/GetLoadBalancerAttributeResult.cc | 91 +++++---- alb/src/model/ListAclsResult.cc | 2 + alb/src/model/ListLoadBalancersRequest.cc | 18 ++ alb/src/model/ListLoadBalancersResult.cc | 6 + alb/src/model/ListServerGroupServersResult.cc | 2 + alb/src/model/ListServerGroupsResult.cc | 8 + .../ReplaceServersInServerGroupRequest.cc | 1 + .../model/UpdateLoadBalancerZonesRequest.cc | 67 +++++++ .../model/UpdateLoadBalancerZonesResult.cc | 51 +++++ .../UpdateServerGroupAttributeRequest.cc | 9 + 47 files changed, 1698 insertions(+), 51 deletions(-) create mode 100644 alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h create mode 100644 alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h create mode 100644 alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h create mode 100644 alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h create mode 100644 alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h create mode 100644 alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h create mode 100644 alb/include/alibabacloud/alb/model/GetListenerHealthStatusRequest.h create mode 100644 alb/include/alibabacloud/alb/model/GetListenerHealthStatusResult.h create mode 100644 alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h create mode 100644 alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h create mode 100644 alb/src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc create mode 100644 alb/src/model/ApplyHealthCheckTemplateToServerGroupResult.cc create mode 100644 alb/src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc create mode 100644 alb/src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc create mode 100644 alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.cc create mode 100644 alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc create mode 100644 alb/src/model/GetListenerHealthStatusRequest.cc create mode 100644 alb/src/model/GetListenerHealthStatusResult.cc create mode 100644 alb/src/model/UpdateLoadBalancerZonesRequest.cc create mode 100644 alb/src/model/UpdateLoadBalancerZonesResult.cc diff --git a/CHANGELOG b/CHANGELOG index 8429c4bb9..7414b625d 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2021-11-30 Version: 1.36.957 +- Support health check paging. + 2021-11-29 Version: 1.36.956 - Add API for unregister sip phone device, masked callee, etc. diff --git a/VERSION b/VERSION index 9eb70b8bd..e58af7236 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.956 \ No newline at end of file +1.36.957 \ No newline at end of file diff --git a/alb/CMakeLists.txt b/alb/CMakeLists.txt index cf78d161e..836a0c0f4 100644 --- a/alb/CMakeLists.txt +++ b/alb/CMakeLists.txt @@ -25,10 +25,14 @@ set(alb_public_header_model include/alibabacloud/alb/model/AddEntriesToAclResult.h include/alibabacloud/alb/model/AddServersToServerGroupRequest.h include/alibabacloud/alb/model/AddServersToServerGroupResult.h + include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h + include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h include/alibabacloud/alb/model/AssociateAclsWithListenerRequest.h include/alibabacloud/alb/model/AssociateAclsWithListenerResult.h include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerRequest.h include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerResult.h + include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h + include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h include/alibabacloud/alb/model/CreateAclRequest.h include/alibabacloud/alb/model/CreateAclResult.h include/alibabacloud/alb/model/CreateHealthCheckTemplateRequest.h @@ -65,6 +69,8 @@ set(alb_public_header_model include/alibabacloud/alb/model/DescribeRegionsResult.h include/alibabacloud/alb/model/DescribeZonesRequest.h include/alibabacloud/alb/model/DescribeZonesResult.h + include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h + include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h include/alibabacloud/alb/model/DisableDeletionProtectionRequest.h include/alibabacloud/alb/model/DisableDeletionProtectionResult.h include/alibabacloud/alb/model/DisableLoadBalancerAccessLogRequest.h @@ -81,6 +87,8 @@ set(alb_public_header_model include/alibabacloud/alb/model/GetHealthCheckTemplateAttributeResult.h include/alibabacloud/alb/model/GetListenerAttributeRequest.h include/alibabacloud/alb/model/GetListenerAttributeResult.h + include/alibabacloud/alb/model/GetListenerHealthStatusRequest.h + include/alibabacloud/alb/model/GetListenerHealthStatusResult.h include/alibabacloud/alb/model/GetLoadBalancerAttributeRequest.h include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h include/alibabacloud/alb/model/ListAclEntriesRequest.h @@ -145,6 +153,8 @@ set(alb_public_header_model include/alibabacloud/alb/model/UpdateLoadBalancerAttributeResult.h include/alibabacloud/alb/model/UpdateLoadBalancerEditionRequest.h include/alibabacloud/alb/model/UpdateLoadBalancerEditionResult.h + include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h + include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h include/alibabacloud/alb/model/UpdateRuleAttributeRequest.h include/alibabacloud/alb/model/UpdateRuleAttributeResult.h include/alibabacloud/alb/model/UpdateRulesAttributeRequest.h @@ -162,10 +172,14 @@ set(alb_src src/model/AddEntriesToAclResult.cc src/model/AddServersToServerGroupRequest.cc src/model/AddServersToServerGroupResult.cc + src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc + src/model/ApplyHealthCheckTemplateToServerGroupResult.cc src/model/AssociateAclsWithListenerRequest.cc src/model/AssociateAclsWithListenerResult.cc src/model/AssociateAdditionalCertificatesWithListenerRequest.cc src/model/AssociateAdditionalCertificatesWithListenerResult.cc + src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc + src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc src/model/CreateAclRequest.cc src/model/CreateAclResult.cc src/model/CreateHealthCheckTemplateRequest.cc @@ -202,6 +216,8 @@ set(alb_src src/model/DescribeRegionsResult.cc src/model/DescribeZonesRequest.cc src/model/DescribeZonesResult.cc + src/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.cc + src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc src/model/DisableDeletionProtectionRequest.cc src/model/DisableDeletionProtectionResult.cc src/model/DisableLoadBalancerAccessLogRequest.cc @@ -218,6 +234,8 @@ set(alb_src src/model/GetHealthCheckTemplateAttributeResult.cc src/model/GetListenerAttributeRequest.cc src/model/GetListenerAttributeResult.cc + src/model/GetListenerHealthStatusRequest.cc + src/model/GetListenerHealthStatusResult.cc src/model/GetLoadBalancerAttributeRequest.cc src/model/GetLoadBalancerAttributeResult.cc src/model/ListAclEntriesRequest.cc @@ -282,6 +300,8 @@ set(alb_src src/model/UpdateLoadBalancerAttributeResult.cc src/model/UpdateLoadBalancerEditionRequest.cc src/model/UpdateLoadBalancerEditionResult.cc + src/model/UpdateLoadBalancerZonesRequest.cc + src/model/UpdateLoadBalancerZonesResult.cc src/model/UpdateRuleAttributeRequest.cc src/model/UpdateRuleAttributeResult.cc src/model/UpdateRulesAttributeRequest.cc diff --git a/alb/include/alibabacloud/alb/AlbClient.h b/alb/include/alibabacloud/alb/AlbClient.h index 2b0228f42..2d01b0dac 100644 --- a/alb/include/alibabacloud/alb/AlbClient.h +++ b/alb/include/alibabacloud/alb/AlbClient.h @@ -26,10 +26,14 @@ #include "model/AddEntriesToAclResult.h" #include "model/AddServersToServerGroupRequest.h" #include "model/AddServersToServerGroupResult.h" +#include "model/ApplyHealthCheckTemplateToServerGroupRequest.h" +#include "model/ApplyHealthCheckTemplateToServerGroupResult.h" #include "model/AssociateAclsWithListenerRequest.h" #include "model/AssociateAclsWithListenerResult.h" #include "model/AssociateAdditionalCertificatesWithListenerRequest.h" #include "model/AssociateAdditionalCertificatesWithListenerResult.h" +#include "model/AttachCommonBandwidthPackageToLoadBalancerRequest.h" +#include "model/AttachCommonBandwidthPackageToLoadBalancerResult.h" #include "model/CreateAclRequest.h" #include "model/CreateAclResult.h" #include "model/CreateHealthCheckTemplateRequest.h" @@ -66,6 +70,8 @@ #include "model/DescribeRegionsResult.h" #include "model/DescribeZonesRequest.h" #include "model/DescribeZonesResult.h" +#include "model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h" +#include "model/DetachCommonBandwidthPackageFromLoadBalancerResult.h" #include "model/DisableDeletionProtectionRequest.h" #include "model/DisableDeletionProtectionResult.h" #include "model/DisableLoadBalancerAccessLogRequest.h" @@ -82,6 +88,8 @@ #include "model/GetHealthCheckTemplateAttributeResult.h" #include "model/GetListenerAttributeRequest.h" #include "model/GetListenerAttributeResult.h" +#include "model/GetListenerHealthStatusRequest.h" +#include "model/GetListenerHealthStatusResult.h" #include "model/GetLoadBalancerAttributeRequest.h" #include "model/GetLoadBalancerAttributeResult.h" #include "model/ListAclEntriesRequest.h" @@ -146,6 +154,8 @@ #include "model/UpdateLoadBalancerAttributeResult.h" #include "model/UpdateLoadBalancerEditionRequest.h" #include "model/UpdateLoadBalancerEditionResult.h" +#include "model/UpdateLoadBalancerZonesRequest.h" +#include "model/UpdateLoadBalancerZonesResult.h" #include "model/UpdateRuleAttributeRequest.h" #include "model/UpdateRuleAttributeResult.h" #include "model/UpdateRulesAttributeRequest.h" @@ -171,12 +181,18 @@ namespace AlibabaCloud typedef Outcome AddServersToServerGroupOutcome; typedef std::future AddServersToServerGroupOutcomeCallable; typedef std::function&)> AddServersToServerGroupAsyncHandler; + typedef Outcome ApplyHealthCheckTemplateToServerGroupOutcome; + typedef std::future ApplyHealthCheckTemplateToServerGroupOutcomeCallable; + typedef std::function&)> ApplyHealthCheckTemplateToServerGroupAsyncHandler; typedef Outcome AssociateAclsWithListenerOutcome; typedef std::future AssociateAclsWithListenerOutcomeCallable; typedef std::function&)> AssociateAclsWithListenerAsyncHandler; typedef Outcome AssociateAdditionalCertificatesWithListenerOutcome; typedef std::future AssociateAdditionalCertificatesWithListenerOutcomeCallable; typedef std::function&)> AssociateAdditionalCertificatesWithListenerAsyncHandler; + typedef Outcome AttachCommonBandwidthPackageToLoadBalancerOutcome; + typedef std::future AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable; + typedef std::function&)> AttachCommonBandwidthPackageToLoadBalancerAsyncHandler; typedef Outcome CreateAclOutcome; typedef std::future CreateAclOutcomeCallable; typedef std::function&)> CreateAclAsyncHandler; @@ -231,6 +247,9 @@ namespace AlibabaCloud typedef Outcome DescribeZonesOutcome; typedef std::future DescribeZonesOutcomeCallable; typedef std::function&)> DescribeZonesAsyncHandler; + typedef Outcome DetachCommonBandwidthPackageFromLoadBalancerOutcome; + typedef std::future DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable; + typedef std::function&)> DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler; typedef Outcome DisableDeletionProtectionOutcome; typedef std::future DisableDeletionProtectionOutcomeCallable; typedef std::function&)> DisableDeletionProtectionAsyncHandler; @@ -255,6 +274,9 @@ namespace AlibabaCloud typedef Outcome GetListenerAttributeOutcome; typedef std::future GetListenerAttributeOutcomeCallable; typedef std::function&)> GetListenerAttributeAsyncHandler; + typedef Outcome GetListenerHealthStatusOutcome; + typedef std::future GetListenerHealthStatusOutcomeCallable; + typedef std::function&)> GetListenerHealthStatusAsyncHandler; typedef Outcome GetLoadBalancerAttributeOutcome; typedef std::future GetLoadBalancerAttributeOutcomeCallable; typedef std::function&)> GetLoadBalancerAttributeAsyncHandler; @@ -351,6 +373,9 @@ namespace AlibabaCloud typedef Outcome UpdateLoadBalancerEditionOutcome; typedef std::future UpdateLoadBalancerEditionOutcomeCallable; typedef std::function&)> UpdateLoadBalancerEditionAsyncHandler; + typedef Outcome UpdateLoadBalancerZonesOutcome; + typedef std::future UpdateLoadBalancerZonesOutcomeCallable; + typedef std::function&)> UpdateLoadBalancerZonesAsyncHandler; typedef Outcome UpdateRuleAttributeOutcome; typedef std::future UpdateRuleAttributeOutcomeCallable; typedef std::function&)> UpdateRuleAttributeAsyncHandler; @@ -377,12 +402,18 @@ namespace AlibabaCloud AddServersToServerGroupOutcome addServersToServerGroup(const Model::AddServersToServerGroupRequest &request)const; void addServersToServerGroupAsync(const Model::AddServersToServerGroupRequest& request, const AddServersToServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddServersToServerGroupOutcomeCallable addServersToServerGroupCallable(const Model::AddServersToServerGroupRequest& request) const; + ApplyHealthCheckTemplateToServerGroupOutcome applyHealthCheckTemplateToServerGroup(const Model::ApplyHealthCheckTemplateToServerGroupRequest &request)const; + void applyHealthCheckTemplateToServerGroupAsync(const Model::ApplyHealthCheckTemplateToServerGroupRequest& request, const ApplyHealthCheckTemplateToServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ApplyHealthCheckTemplateToServerGroupOutcomeCallable applyHealthCheckTemplateToServerGroupCallable(const Model::ApplyHealthCheckTemplateToServerGroupRequest& request) const; AssociateAclsWithListenerOutcome associateAclsWithListener(const Model::AssociateAclsWithListenerRequest &request)const; void associateAclsWithListenerAsync(const Model::AssociateAclsWithListenerRequest& request, const AssociateAclsWithListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AssociateAclsWithListenerOutcomeCallable associateAclsWithListenerCallable(const Model::AssociateAclsWithListenerRequest& request) const; AssociateAdditionalCertificatesWithListenerOutcome associateAdditionalCertificatesWithListener(const Model::AssociateAdditionalCertificatesWithListenerRequest &request)const; void associateAdditionalCertificatesWithListenerAsync(const Model::AssociateAdditionalCertificatesWithListenerRequest& request, const AssociateAdditionalCertificatesWithListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AssociateAdditionalCertificatesWithListenerOutcomeCallable associateAdditionalCertificatesWithListenerCallable(const Model::AssociateAdditionalCertificatesWithListenerRequest& request) const; + AttachCommonBandwidthPackageToLoadBalancerOutcome attachCommonBandwidthPackageToLoadBalancer(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest &request)const; + void attachCommonBandwidthPackageToLoadBalancerAsync(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest& request, const AttachCommonBandwidthPackageToLoadBalancerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable attachCommonBandwidthPackageToLoadBalancerCallable(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest& request) const; CreateAclOutcome createAcl(const Model::CreateAclRequest &request)const; void createAclAsync(const Model::CreateAclRequest& request, const CreateAclAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateAclOutcomeCallable createAclCallable(const Model::CreateAclRequest& request) const; @@ -437,6 +468,9 @@ namespace AlibabaCloud DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const; void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const; + DetachCommonBandwidthPackageFromLoadBalancerOutcome detachCommonBandwidthPackageFromLoadBalancer(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest &request)const; + void detachCommonBandwidthPackageFromLoadBalancerAsync(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest& request, const DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable detachCommonBandwidthPackageFromLoadBalancerCallable(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest& request) const; DisableDeletionProtectionOutcome disableDeletionProtection(const Model::DisableDeletionProtectionRequest &request)const; void disableDeletionProtectionAsync(const Model::DisableDeletionProtectionRequest& request, const DisableDeletionProtectionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DisableDeletionProtectionOutcomeCallable disableDeletionProtectionCallable(const Model::DisableDeletionProtectionRequest& request) const; @@ -461,6 +495,9 @@ namespace AlibabaCloud GetListenerAttributeOutcome getListenerAttribute(const Model::GetListenerAttributeRequest &request)const; void getListenerAttributeAsync(const Model::GetListenerAttributeRequest& request, const GetListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetListenerAttributeOutcomeCallable getListenerAttributeCallable(const Model::GetListenerAttributeRequest& request) const; + GetListenerHealthStatusOutcome getListenerHealthStatus(const Model::GetListenerHealthStatusRequest &request)const; + void getListenerHealthStatusAsync(const Model::GetListenerHealthStatusRequest& request, const GetListenerHealthStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetListenerHealthStatusOutcomeCallable getListenerHealthStatusCallable(const Model::GetListenerHealthStatusRequest& request) const; GetLoadBalancerAttributeOutcome getLoadBalancerAttribute(const Model::GetLoadBalancerAttributeRequest &request)const; void getLoadBalancerAttributeAsync(const Model::GetLoadBalancerAttributeRequest& request, const GetLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetLoadBalancerAttributeOutcomeCallable getLoadBalancerAttributeCallable(const Model::GetLoadBalancerAttributeRequest& request) const; @@ -557,6 +594,9 @@ namespace AlibabaCloud UpdateLoadBalancerEditionOutcome updateLoadBalancerEdition(const Model::UpdateLoadBalancerEditionRequest &request)const; void updateLoadBalancerEditionAsync(const Model::UpdateLoadBalancerEditionRequest& request, const UpdateLoadBalancerEditionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateLoadBalancerEditionOutcomeCallable updateLoadBalancerEditionCallable(const Model::UpdateLoadBalancerEditionRequest& request) const; + UpdateLoadBalancerZonesOutcome updateLoadBalancerZones(const Model::UpdateLoadBalancerZonesRequest &request)const; + void updateLoadBalancerZonesAsync(const Model::UpdateLoadBalancerZonesRequest& request, const UpdateLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateLoadBalancerZonesOutcomeCallable updateLoadBalancerZonesCallable(const Model::UpdateLoadBalancerZonesRequest& request) const; UpdateRuleAttributeOutcome updateRuleAttribute(const Model::UpdateRuleAttributeRequest &request)const; void updateRuleAttributeAsync(const Model::UpdateRuleAttributeRequest& request, const UpdateRuleAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateRuleAttributeOutcomeCallable updateRuleAttributeCallable(const Model::UpdateRuleAttributeRequest& request) const; diff --git a/alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h b/alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h index dc8b3c4b0..4a568df53 100644 --- a/alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h +++ b/alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h @@ -29,6 +29,7 @@ namespace Model { class ALIBABACLOUD_ALB_EXPORT AddServersToServerGroupRequest : public RpcServiceRequest { public: struct Servers { + bool remoteIpEnabled; std::string serverType; int port; std::string description; diff --git a/alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h b/alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h new file mode 100644 index 000000000..19ec85c9a --- /dev/null +++ b/alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.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_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Alb { +namespace Model { +class ALIBABACLOUD_ALB_EXPORT ApplyHealthCheckTemplateToServerGroupRequest : public RpcServiceRequest { +public: + ApplyHealthCheckTemplateToServerGroupRequest(); + ~ApplyHealthCheckTemplateToServerGroupRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getServerGroupId() const; + void setServerGroupId(const std::string &serverGroupId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getHealthCheckTemplateId() const; + void setHealthCheckTemplateId(const std::string &healthCheckTemplateId); + +private: + std::string clientToken_; + std::string serverGroupId_; + bool dryRun_; + std::string healthCheckTemplateId_; +}; +} // namespace Model +} // namespace Alb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_ diff --git a/alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h b/alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h new file mode 100644 index 000000000..9290cdcd6 --- /dev/null +++ b/alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.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_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_ +#define ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alb + { + namespace Model + { + class ALIBABACLOUD_ALB_EXPORT ApplyHealthCheckTemplateToServerGroupResult : public ServiceResult + { + public: + + + ApplyHealthCheckTemplateToServerGroupResult(); + explicit ApplyHealthCheckTemplateToServerGroupResult(const std::string &payload); + ~ApplyHealthCheckTemplateToServerGroupResult(); + std::string getJobId()const; + + protected: + void parse(const std::string &payload); + private: + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h b/alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h new file mode 100644 index 000000000..a13b2cadd --- /dev/null +++ b/alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.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_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_ +#define ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Alb { +namespace Model { +class ALIBABACLOUD_ALB_EXPORT AttachCommonBandwidthPackageToLoadBalancerRequest : public RpcServiceRequest { +public: + AttachCommonBandwidthPackageToLoadBalancerRequest(); + ~AttachCommonBandwidthPackageToLoadBalancerRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getBandwidthPackageId() const; + void setBandwidthPackageId(const std::string &bandwidthPackageId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getLoadBalancerId() const; + void setLoadBalancerId(const std::string &loadBalancerId); + +private: + std::string clientToken_; + std::string regionId_; + std::string bandwidthPackageId_; + bool dryRun_; + std::string loadBalancerId_; +}; +} // namespace Model +} // namespace Alb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_ diff --git a/alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h b/alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h new file mode 100644 index 000000000..ff91172f6 --- /dev/null +++ b/alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.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_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_ +#define ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alb + { + namespace Model + { + class ALIBABACLOUD_ALB_EXPORT AttachCommonBandwidthPackageToLoadBalancerResult : public ServiceResult + { + public: + + + AttachCommonBandwidthPackageToLoadBalancerResult(); + explicit AttachCommonBandwidthPackageToLoadBalancerResult(const std::string &payload); + ~AttachCommonBandwidthPackageToLoadBalancerResult(); + std::string getJobId()const; + + protected: + void parse(const std::string &payload); + private: + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_ \ No newline at end of file diff --git a/alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h b/alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h index c0426c833..864b53398 100644 --- a/alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h +++ b/alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h @@ -33,6 +33,7 @@ public: std::string status; }; struct LoadBalancerBillingConfig { + std::string bandwidthPackageId; std::string internetChargeType; int internetBandwidth; std::string payType; @@ -40,6 +41,7 @@ public: struct ZoneMappings { std::string vSwitchId; std::string zoneId; + std::string allocationId; }; CreateLoadBalancerRequest(); ~CreateLoadBalancerRequest(); @@ -51,6 +53,8 @@ public: void setModificationProtectionConfig(const ModificationProtectionConfig &modificationProtectionConfig); LoadBalancerBillingConfig getLoadBalancerBillingConfig() const; void setLoadBalancerBillingConfig(const LoadBalancerBillingConfig &loadBalancerBillingConfig); + std::string getAddressIpVersion() const; + void setAddressIpVersion(const std::string &addressIpVersion); bool getDeletionProtectionEnabled() const; void setDeletionProtectionEnabled(bool deletionProtectionEnabled); std::string getResourceGroupId() const; @@ -73,6 +77,7 @@ private: std::string clientToken_; ModificationProtectionConfig modificationProtectionConfig_; LoadBalancerBillingConfig loadBalancerBillingConfig_; + std::string addressIpVersion_; bool deletionProtectionEnabled_; std::string resourceGroupId_; std::string loadBalancerName_; diff --git a/alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h b/alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h index 284f10dd1..1c6e1a7ea 100644 --- a/alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h +++ b/alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h @@ -66,10 +66,14 @@ public: void setResourceGroupId(const std::string &resourceGroupId); std::string getProtocol() const; void setProtocol(const std::string &protocol); + bool getUpstreamKeepaliveEnabled() const; + void setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled); StickySessionConfig getStickySessionConfig() const; void setStickySessionConfig(const StickySessionConfig &stickySessionConfig); bool getDryRun() const; void setDryRun(bool dryRun); + bool getIpv6Enabled() const; + void setIpv6Enabled(bool ipv6Enabled); std::string getServerGroupType() const; void setServerGroupType(const std::string &serverGroupType); std::string getVpcId() const; @@ -82,8 +86,10 @@ private: std::string scheduler_; std::string resourceGroupId_; std::string protocol_; + bool upstreamKeepaliveEnabled_; StickySessionConfig stickySessionConfig_; bool dryRun_; + bool ipv6Enabled_; std::string serverGroupType_; std::string vpcId_; }; diff --git a/alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h b/alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h new file mode 100644 index 000000000..bf7d891b7 --- /dev/null +++ b/alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.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_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_ +#define ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Alb { +namespace Model { +class ALIBABACLOUD_ALB_EXPORT DetachCommonBandwidthPackageFromLoadBalancerRequest : public RpcServiceRequest { +public: + DetachCommonBandwidthPackageFromLoadBalancerRequest(); + ~DetachCommonBandwidthPackageFromLoadBalancerRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getBandwidthPackageId() const; + void setBandwidthPackageId(const std::string &bandwidthPackageId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getLoadBalancerId() const; + void setLoadBalancerId(const std::string &loadBalancerId); + +private: + std::string clientToken_; + std::string regionId_; + std::string bandwidthPackageId_; + bool dryRun_; + std::string loadBalancerId_; +}; +} // namespace Model +} // namespace Alb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_ diff --git a/alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h b/alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h new file mode 100644 index 000000000..42e724658 --- /dev/null +++ b/alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.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_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_ +#define ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alb + { + namespace Model + { + class ALIBABACLOUD_ALB_EXPORT DetachCommonBandwidthPackageFromLoadBalancerResult : public ServiceResult + { + public: + + + DetachCommonBandwidthPackageFromLoadBalancerResult(); + explicit DetachCommonBandwidthPackageFromLoadBalancerResult(const std::string &payload); + ~DetachCommonBandwidthPackageFromLoadBalancerResult(); + std::string getJobId()const; + + protected: + void parse(const std::string &payload); + private: + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_ \ No newline at end of file diff --git a/alb/include/alibabacloud/alb/model/GetListenerHealthStatusRequest.h b/alb/include/alibabacloud/alb/model/GetListenerHealthStatusRequest.h new file mode 100644 index 000000000..eca9497be --- /dev/null +++ b/alb/include/alibabacloud/alb/model/GetListenerHealthStatusRequest.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_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_ +#define ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Alb { +namespace Model { +class ALIBABACLOUD_ALB_EXPORT GetListenerHealthStatusRequest : public RpcServiceRequest { +public: + GetListenerHealthStatusRequest(); + ~GetListenerHealthStatusRequest(); + bool getIncludeRule() const; + void setIncludeRule(bool includeRule); + std::string getListenerId() const; + void setListenerId(const std::string &listenerId); + std::string getNextToken() const; + void setNextToken(const std::string &nextToken); + long getMaxResults() const; + void setMaxResults(long maxResults); + +private: + bool includeRule_; + std::string listenerId_; + std::string nextToken_; + long maxResults_; +}; +} // namespace Model +} // namespace Alb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_ diff --git a/alb/include/alibabacloud/alb/model/GetListenerHealthStatusResult.h b/alb/include/alibabacloud/alb/model/GetListenerHealthStatusResult.h new file mode 100644 index 000000000..625cd807a --- /dev/null +++ b/alb/include/alibabacloud/alb/model/GetListenerHealthStatusResult.h @@ -0,0 +1,109 @@ +/* + * 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_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_ +#define ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alb + { + namespace Model + { + class ALIBABACLOUD_ALB_EXPORT GetListenerHealthStatusResult : public ServiceResult + { + public: + struct ListenerHealthStatusModel + { + struct ServerGroupHealthStatusModel + { + struct BackendServerHealthStatusModel + { + struct Reason + { + std::string expectedResponse; + std::string actualResponse; + std::string reasonCode; + }; + std::string status; + std::string serverId; + int port; + std::string serverIp; + Reason reason; + }; + std::string actionType; + std::vector nonNormalServers; + std::string serverGroupId; + std::string healthCheckEnabled; + }; + int listenerPort; + std::vector serverGroupInfos; + std::string listenerProtocol; + std::string listenerId; + }; + struct RuleHealthStatusModel + { + struct ServerGroupHealthStatusModel2 + { + struct NonNormalServer + { + struct Reason4 + { + std::string expectedResponse; + std::string actualResponse; + std::string reasonCode; + }; + std::string status; + std::string serverId; + Reason4 reason4; + int port; + std::string serverIp; + }; + std::string actionType; + std::string serverGroupId; + std::string healthCheckEnabled; + std::vector nonNormalServers3; + }; + std::vector serverGroupInfos1; + std::string ruleId; + }; + + + GetListenerHealthStatusResult(); + explicit GetListenerHealthStatusResult(const std::string &payload); + ~GetListenerHealthStatusResult(); + std::vector getRuleHealthStatus()const; + std::vector getListenerHealthStatus()const; + std::string getNextToken()const; + + protected: + void parse(const std::string &payload); + private: + std::vector ruleHealthStatus_; + std::vector listenerHealthStatus_; + std::string nextToken_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_ \ No newline at end of file diff --git a/alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h b/alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h index 5ec006ad9..bc996506a 100644 --- a/alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h +++ b/alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h @@ -68,6 +68,7 @@ namespace AlibabaCloud struct LoadBalancerAddress { std::string address; + std::string ipv6Address; }; std::string zoneId; std::string vSwitchId; @@ -79,56 +80,62 @@ namespace AlibabaCloud explicit GetLoadBalancerAttributeResult(const std::string &payload); ~GetLoadBalancerAttributeResult(); bool getServiceManagedEnabled()const; - std::string getLoadBalancerEdition()const; + std::string getAddressIpVersion()const; std::string getResourceGroupId()const; - LoadBalancerBillingConfig getLoadBalancerBillingConfig()const; std::vector getFeatureLabels()const; - std::string getCreateTime()const; std::string getLoadBalancerId()const; std::vector getZoneMappings()const; std::string getDNSName()const; + std::string getIpv6AddressType()const; + int getBandwidthCapacity()const; + DeletionProtectionConfig getDeletionProtectionConfig()const; + std::string getServiceManagedMode()const; + std::string getBandwidthPackageId()const; + std::vector getTags()const; + std::string getLoadBalancerEdition()const; + LoadBalancerBillingConfig getLoadBalancerBillingConfig()const; + std::string getCreateTime()const; ModificationProtectionConfig getModificationProtectionConfig()const; std::string getLoadBalancerName()const; AccessLogConfig getAccessLogConfig()const; - int getBandwidthCapacity()const; - DeletionProtectionConfig getDeletionProtectionConfig()const; + bool getConfigManagedEnabled()const; std::string getLoadBalancerBussinessStatus()const; std::string getVpcId()const; - std::string getServiceManagedMode()const; - std::string getBandwidthPackageId()const; std::string getRegionId()const; std::string getAddressAllocatedMode()const; std::string getAddressType()const; std::string getLoadBalancerStatus()const; - std::vector getTags()const; std::vector getLoadBalancerOperationLocks()const; protected: void parse(const std::string &payload); private: bool serviceManagedEnabled_; - std::string loadBalancerEdition_; + std::string addressIpVersion_; std::string resourceGroupId_; - LoadBalancerBillingConfig loadBalancerBillingConfig_; std::vector featureLabels_; - std::string createTime_; std::string loadBalancerId_; std::vector zoneMappings_; std::string dNSName_; + std::string ipv6AddressType_; + int bandwidthCapacity_; + DeletionProtectionConfig deletionProtectionConfig_; + std::string serviceManagedMode_; + std::string bandwidthPackageId_; + std::vector tags_; + std::string loadBalancerEdition_; + LoadBalancerBillingConfig loadBalancerBillingConfig_; + std::string createTime_; ModificationProtectionConfig modificationProtectionConfig_; std::string loadBalancerName_; AccessLogConfig accessLogConfig_; - int bandwidthCapacity_; - DeletionProtectionConfig deletionProtectionConfig_; + bool configManagedEnabled_; std::string loadBalancerBussinessStatus_; std::string vpcId_; - std::string serviceManagedMode_; - std::string bandwidthPackageId_; std::string regionId_; std::string addressAllocatedMode_; std::string addressType_; std::string loadBalancerStatus_; - std::vector tags_; std::vector loadBalancerOperationLocks_; }; diff --git a/alb/include/alibabacloud/alb/model/ListAclsResult.h b/alb/include/alibabacloud/alb/model/ListAclsResult.h index ecc98845a..e30e24f5b 100644 --- a/alb/include/alibabacloud/alb/model/ListAclsResult.h +++ b/alb/include/alibabacloud/alb/model/ListAclsResult.h @@ -35,6 +35,7 @@ namespace AlibabaCloud struct Acl { bool serviceManagedEnabled; + bool configManagedEnabled; std::string aclStatus; std::string resourceGroupId; std::string aclId; diff --git a/alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h b/alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h index 46736183d..6c4df3a3d 100644 --- a/alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h +++ b/alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h @@ -38,6 +38,8 @@ public: void setLoadBalancerNames(const std::vector &loadBalancerNames); std::vector getLoadBalancerIds() const; void setLoadBalancerIds(const std::vector &loadBalancerIds); + std::string getAddressIpVersion() const; + void setAddressIpVersion(const std::string &addressIpVersion); std::string getResourceGroupId() const; void setResourceGroupId(const std::string &resourceGroupId); std::string getNextToken() const; @@ -60,12 +62,15 @@ public: void setMaxResults(int maxResults); std::string getZoneId() const; void setZoneId(const std::string &zoneId); + std::string getIpv6AddressType() const; + void setIpv6AddressType(const std::string &ipv6AddressType); std::string getPayType() const; void setPayType(const std::string &payType); private: std::vector loadBalancerNames_; std::vector loadBalancerIds_; + std::string addressIpVersion_; std::string resourceGroupId_; std::string nextToken_; std::string loadBalancerBussinessStatus_; @@ -77,6 +82,7 @@ private: std::string internetChargeType_; int maxResults_; std::string zoneId_; + std::string ipv6AddressType_; std::string payType_; }; } // namespace Model diff --git a/alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h b/alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h index dfeffb757..6609743ad 100644 --- a/alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h +++ b/alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h @@ -67,15 +67,18 @@ namespace AlibabaCloud }; bool serviceManagedEnabled; std::string loadBalancerEdition; + std::string addressIpVersion; std::string resourceGroupId; LoadBalancerBillingConfig loadBalancerBillingConfig; std::string createTime; std::string loadBalancerId; std::string dNSName; ModificationProtectionConfig modificationProtectionConfig; + std::string ipv6AddressType; std::string loadBalancerName; AccessLogConfig accessLogConfig; int bandwidthCapacity; + bool configManagedEnabled; DeletionProtectionConfig deletionProtectionConfig; std::string loadBalancerBussinessStatus; std::string vpcId; diff --git a/alb/include/alibabacloud/alb/model/ListServerGroupServersResult.h b/alb/include/alibabacloud/alb/model/ListServerGroupServersResult.h index 70c336e15..9d4ce793c 100644 --- a/alb/include/alibabacloud/alb/model/ListServerGroupServersResult.h +++ b/alb/include/alibabacloud/alb/model/ListServerGroupServersResult.h @@ -40,6 +40,7 @@ namespace AlibabaCloud std::string serverId; int port; std::string serverIp; + bool remoteIpEnabled; std::string serverGroupId; int weight; }; diff --git a/alb/include/alibabacloud/alb/model/ListServerGroupsResult.h b/alb/include/alibabacloud/alb/model/ListServerGroupsResult.h index a1de4c88a..b2ecebc2e 100644 --- a/alb/include/alibabacloud/alb/model/ListServerGroupsResult.h +++ b/alb/include/alibabacloud/alb/model/ListServerGroupsResult.h @@ -67,10 +67,14 @@ namespace AlibabaCloud std::vector relatedLoadBalancerIds; std::string resourceGroupId; std::string scheduler; + bool upstreamKeepaliveEnabled; StickySessionConfig stickySessionConfig; std::string serverGroupId; + int serverCount; std::string serverGroupType; std::string serverGroupStatus; + bool ipv6Enabled; + bool configManagedEnabled; std::string vpcId; std::string serviceManagedMode; HealthCheckConfig healthCheckConfig; diff --git a/alb/include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h b/alb/include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h index 48a6bda76..305f03b57 100644 --- a/alb/include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h +++ b/alb/include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h @@ -29,6 +29,7 @@ namespace Model { class ALIBABACLOUD_ALB_EXPORT ReplaceServersInServerGroupRequest : public RpcServiceRequest { public: struct AddedServers { + bool remoteIpEnabled; std::string serverType; int port; std::string description; diff --git a/alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h b/alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h new file mode 100644 index 000000000..7fe487c89 --- /dev/null +++ b/alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.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_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_ +#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Alb { +namespace Model { +class ALIBABACLOUD_ALB_EXPORT UpdateLoadBalancerZonesRequest : public RpcServiceRequest { +public: + struct ZoneMappings { + std::string vSwitchId; + std::string zoneId; + std::string allocationId; + }; + UpdateLoadBalancerZonesRequest(); + ~UpdateLoadBalancerZonesRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::vector getZoneMappings() const; + void setZoneMappings(const std::vector &zoneMappings); + std::string getLoadBalancerId() const; + void setLoadBalancerId(const std::string &loadBalancerId); + +private: + std::string clientToken_; + bool dryRun_; + std::vector zoneMappings_; + std::string loadBalancerId_; +}; +} // namespace Model +} // namespace Alb +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_ diff --git a/alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h b/alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h new file mode 100644 index 000000000..435c03f8d --- /dev/null +++ b/alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.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_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_ +#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alb + { + namespace Model + { + class ALIBABACLOUD_ALB_EXPORT UpdateLoadBalancerZonesResult : public ServiceResult + { + public: + + + UpdateLoadBalancerZonesResult(); + explicit UpdateLoadBalancerZonesResult(const std::string &payload); + ~UpdateLoadBalancerZonesResult(); + std::string getJobId()const; + + protected: + void parse(const std::string &payload); + private: + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_ \ No newline at end of file diff --git a/alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h b/alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h index 2c78f56db..e9966b8e9 100644 --- a/alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h +++ b/alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h @@ -64,6 +64,8 @@ public: void setScheduler(const std::string &scheduler); std::string getServerGroupId() const; void setServerGroupId(const std::string &serverGroupId); + bool getUpstreamKeepaliveEnabled() const; + void setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled); StickySessionConfig getStickySessionConfig() const; void setStickySessionConfig(const StickySessionConfig &stickySessionConfig); bool getDryRun() const; @@ -75,6 +77,7 @@ private: HealthCheckConfig healthCheckConfig_; std::string scheduler_; std::string serverGroupId_; + bool upstreamKeepaliveEnabled_; StickySessionConfig stickySessionConfig_; bool dryRun_; }; diff --git a/alb/src/AlbClient.cc b/alb/src/AlbClient.cc index 7042f7997..642beb37f 100644 --- a/alb/src/AlbClient.cc +++ b/alb/src/AlbClient.cc @@ -123,6 +123,42 @@ AlbClient::AddServersToServerGroupOutcomeCallable AlbClient::addServersToServerG return task->get_future(); } +AlbClient::ApplyHealthCheckTemplateToServerGroupOutcome AlbClient::applyHealthCheckTemplateToServerGroup(const ApplyHealthCheckTemplateToServerGroupRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ApplyHealthCheckTemplateToServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ApplyHealthCheckTemplateToServerGroupOutcome(ApplyHealthCheckTemplateToServerGroupResult(outcome.result())); + else + return ApplyHealthCheckTemplateToServerGroupOutcome(outcome.error()); +} + +void AlbClient::applyHealthCheckTemplateToServerGroupAsync(const ApplyHealthCheckTemplateToServerGroupRequest& request, const ApplyHealthCheckTemplateToServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, applyHealthCheckTemplateToServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlbClient::ApplyHealthCheckTemplateToServerGroupOutcomeCallable AlbClient::applyHealthCheckTemplateToServerGroupCallable(const ApplyHealthCheckTemplateToServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->applyHealthCheckTemplateToServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlbClient::AssociateAclsWithListenerOutcome AlbClient::associateAclsWithListener(const AssociateAclsWithListenerRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -195,6 +231,42 @@ AlbClient::AssociateAdditionalCertificatesWithListenerOutcomeCallable AlbClient: return task->get_future(); } +AlbClient::AttachCommonBandwidthPackageToLoadBalancerOutcome AlbClient::attachCommonBandwidthPackageToLoadBalancer(const AttachCommonBandwidthPackageToLoadBalancerRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AttachCommonBandwidthPackageToLoadBalancerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AttachCommonBandwidthPackageToLoadBalancerOutcome(AttachCommonBandwidthPackageToLoadBalancerResult(outcome.result())); + else + return AttachCommonBandwidthPackageToLoadBalancerOutcome(outcome.error()); +} + +void AlbClient::attachCommonBandwidthPackageToLoadBalancerAsync(const AttachCommonBandwidthPackageToLoadBalancerRequest& request, const AttachCommonBandwidthPackageToLoadBalancerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, attachCommonBandwidthPackageToLoadBalancer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlbClient::AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable AlbClient::attachCommonBandwidthPackageToLoadBalancerCallable(const AttachCommonBandwidthPackageToLoadBalancerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->attachCommonBandwidthPackageToLoadBalancer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlbClient::CreateAclOutcome AlbClient::createAcl(const CreateAclRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -843,6 +915,42 @@ AlbClient::DescribeZonesOutcomeCallable AlbClient::describeZonesCallable(const D return task->get_future(); } +AlbClient::DetachCommonBandwidthPackageFromLoadBalancerOutcome AlbClient::detachCommonBandwidthPackageFromLoadBalancer(const DetachCommonBandwidthPackageFromLoadBalancerRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DetachCommonBandwidthPackageFromLoadBalancerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DetachCommonBandwidthPackageFromLoadBalancerOutcome(DetachCommonBandwidthPackageFromLoadBalancerResult(outcome.result())); + else + return DetachCommonBandwidthPackageFromLoadBalancerOutcome(outcome.error()); +} + +void AlbClient::detachCommonBandwidthPackageFromLoadBalancerAsync(const DetachCommonBandwidthPackageFromLoadBalancerRequest& request, const DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, detachCommonBandwidthPackageFromLoadBalancer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlbClient::DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable AlbClient::detachCommonBandwidthPackageFromLoadBalancerCallable(const DetachCommonBandwidthPackageFromLoadBalancerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->detachCommonBandwidthPackageFromLoadBalancer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlbClient::DisableDeletionProtectionOutcome AlbClient::disableDeletionProtection(const DisableDeletionProtectionRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1131,6 +1239,42 @@ AlbClient::GetListenerAttributeOutcomeCallable AlbClient::getListenerAttributeCa return task->get_future(); } +AlbClient::GetListenerHealthStatusOutcome AlbClient::getListenerHealthStatus(const GetListenerHealthStatusRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetListenerHealthStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetListenerHealthStatusOutcome(GetListenerHealthStatusResult(outcome.result())); + else + return GetListenerHealthStatusOutcome(outcome.error()); +} + +void AlbClient::getListenerHealthStatusAsync(const GetListenerHealthStatusRequest& request, const GetListenerHealthStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getListenerHealthStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlbClient::GetListenerHealthStatusOutcomeCallable AlbClient::getListenerHealthStatusCallable(const GetListenerHealthStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getListenerHealthStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlbClient::GetLoadBalancerAttributeOutcome AlbClient::getLoadBalancerAttribute(const GetLoadBalancerAttributeRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2283,6 +2427,42 @@ AlbClient::UpdateLoadBalancerEditionOutcomeCallable AlbClient::updateLoadBalance return task->get_future(); } +AlbClient::UpdateLoadBalancerZonesOutcome AlbClient::updateLoadBalancerZones(const UpdateLoadBalancerZonesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateLoadBalancerZonesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateLoadBalancerZonesOutcome(UpdateLoadBalancerZonesResult(outcome.result())); + else + return UpdateLoadBalancerZonesOutcome(outcome.error()); +} + +void AlbClient::updateLoadBalancerZonesAsync(const UpdateLoadBalancerZonesRequest& request, const UpdateLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateLoadBalancerZones(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlbClient::UpdateLoadBalancerZonesOutcomeCallable AlbClient::updateLoadBalancerZonesCallable(const UpdateLoadBalancerZonesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateLoadBalancerZones(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlbClient::UpdateRuleAttributeOutcome AlbClient::updateRuleAttribute(const UpdateRuleAttributeRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/alb/src/model/AddServersToServerGroupRequest.cc b/alb/src/model/AddServersToServerGroupRequest.cc index 52c1edd97..9b63f6434 100644 --- a/alb/src/model/AddServersToServerGroupRequest.cc +++ b/alb/src/model/AddServersToServerGroupRequest.cc @@ -50,6 +50,7 @@ std::vector AddServersToServerGroupRequ void AddServersToServerGroupRequest::setServers(const std::vector &servers) { servers_ = servers; for(int dep1 = 0; dep1 != servers.size(); dep1++) { + setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".RemoteIpEnabled", servers[dep1].remoteIpEnabled ? "true" : "false"); setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".ServerType", servers[dep1].serverType); setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Port", std::to_string(servers[dep1].port)); setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Description", servers[dep1].description); diff --git a/alb/src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc b/alb/src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc new file mode 100644 index 000000000..217582ca7 --- /dev/null +++ b/alb/src/model/ApplyHealthCheckTemplateToServerGroupRequest.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 + +using AlibabaCloud::Alb::Model::ApplyHealthCheckTemplateToServerGroupRequest; + +ApplyHealthCheckTemplateToServerGroupRequest::ApplyHealthCheckTemplateToServerGroupRequest() + : RpcServiceRequest("alb", "2020-06-16", "ApplyHealthCheckTemplateToServerGroup") { + setMethod(HttpRequest::Method::Post); +} + +ApplyHealthCheckTemplateToServerGroupRequest::~ApplyHealthCheckTemplateToServerGroupRequest() {} + +std::string ApplyHealthCheckTemplateToServerGroupRequest::getClientToken() const { + return clientToken_; +} + +void ApplyHealthCheckTemplateToServerGroupRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string ApplyHealthCheckTemplateToServerGroupRequest::getServerGroupId() const { + return serverGroupId_; +} + +void ApplyHealthCheckTemplateToServerGroupRequest::setServerGroupId(const std::string &serverGroupId) { + serverGroupId_ = serverGroupId; + setParameter(std::string("ServerGroupId"), serverGroupId); +} + +bool ApplyHealthCheckTemplateToServerGroupRequest::getDryRun() const { + return dryRun_; +} + +void ApplyHealthCheckTemplateToServerGroupRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string ApplyHealthCheckTemplateToServerGroupRequest::getHealthCheckTemplateId() const { + return healthCheckTemplateId_; +} + +void ApplyHealthCheckTemplateToServerGroupRequest::setHealthCheckTemplateId(const std::string &healthCheckTemplateId) { + healthCheckTemplateId_ = healthCheckTemplateId; + setParameter(std::string("HealthCheckTemplateId"), healthCheckTemplateId); +} + diff --git a/alb/src/model/ApplyHealthCheckTemplateToServerGroupResult.cc b/alb/src/model/ApplyHealthCheckTemplateToServerGroupResult.cc new file mode 100644 index 000000000..43e0c9abc --- /dev/null +++ b/alb/src/model/ApplyHealthCheckTemplateToServerGroupResult.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::Alb; +using namespace AlibabaCloud::Alb::Model; + +ApplyHealthCheckTemplateToServerGroupResult::ApplyHealthCheckTemplateToServerGroupResult() : + ServiceResult() +{} + +ApplyHealthCheckTemplateToServerGroupResult::ApplyHealthCheckTemplateToServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ApplyHealthCheckTemplateToServerGroupResult::~ApplyHealthCheckTemplateToServerGroupResult() +{} + +void ApplyHealthCheckTemplateToServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["JobId"].isNull()) + jobId_ = value["JobId"].asString(); + +} + +std::string ApplyHealthCheckTemplateToServerGroupResult::getJobId()const +{ + return jobId_; +} + diff --git a/alb/src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc b/alb/src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc new file mode 100644 index 000000000..048cc94c6 --- /dev/null +++ b/alb/src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.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::Alb::Model::AttachCommonBandwidthPackageToLoadBalancerRequest; + +AttachCommonBandwidthPackageToLoadBalancerRequest::AttachCommonBandwidthPackageToLoadBalancerRequest() + : RpcServiceRequest("alb", "2020-06-16", "AttachCommonBandwidthPackageToLoadBalancer") { + setMethod(HttpRequest::Method::Post); +} + +AttachCommonBandwidthPackageToLoadBalancerRequest::~AttachCommonBandwidthPackageToLoadBalancerRequest() {} + +std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getClientToken() const { + return clientToken_; +} + +void AttachCommonBandwidthPackageToLoadBalancerRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getRegionId() const { + return regionId_; +} + +void AttachCommonBandwidthPackageToLoadBalancerRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getBandwidthPackageId() const { + return bandwidthPackageId_; +} + +void AttachCommonBandwidthPackageToLoadBalancerRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) { + bandwidthPackageId_ = bandwidthPackageId; + setParameter(std::string("BandwidthPackageId"), bandwidthPackageId); +} + +bool AttachCommonBandwidthPackageToLoadBalancerRequest::getDryRun() const { + return dryRun_; +} + +void AttachCommonBandwidthPackageToLoadBalancerRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getLoadBalancerId() const { + return loadBalancerId_; +} + +void AttachCommonBandwidthPackageToLoadBalancerRequest::setLoadBalancerId(const std::string &loadBalancerId) { + loadBalancerId_ = loadBalancerId; + setParameter(std::string("LoadBalancerId"), loadBalancerId); +} + diff --git a/alb/src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc b/alb/src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc new file mode 100644 index 000000000..927e0fdb8 --- /dev/null +++ b/alb/src/model/AttachCommonBandwidthPackageToLoadBalancerResult.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::Alb; +using namespace AlibabaCloud::Alb::Model; + +AttachCommonBandwidthPackageToLoadBalancerResult::AttachCommonBandwidthPackageToLoadBalancerResult() : + ServiceResult() +{} + +AttachCommonBandwidthPackageToLoadBalancerResult::AttachCommonBandwidthPackageToLoadBalancerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AttachCommonBandwidthPackageToLoadBalancerResult::~AttachCommonBandwidthPackageToLoadBalancerResult() +{} + +void AttachCommonBandwidthPackageToLoadBalancerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["JobId"].isNull()) + jobId_ = value["JobId"].asString(); + +} + +std::string AttachCommonBandwidthPackageToLoadBalancerResult::getJobId()const +{ + return jobId_; +} + diff --git a/alb/src/model/CreateLoadBalancerRequest.cc b/alb/src/model/CreateLoadBalancerRequest.cc index bec71c4c9..794201554 100644 --- a/alb/src/model/CreateLoadBalancerRequest.cc +++ b/alb/src/model/CreateLoadBalancerRequest.cc @@ -59,11 +59,21 @@ CreateLoadBalancerRequest::LoadBalancerBillingConfig CreateLoadBalancerRequest:: void CreateLoadBalancerRequest::setLoadBalancerBillingConfig(const CreateLoadBalancerRequest::LoadBalancerBillingConfig &loadBalancerBillingConfig) { loadBalancerBillingConfig_ = loadBalancerBillingConfig; + setParameter(std::string("LoadBalancerBillingConfig") + ".BandwidthPackageId", loadBalancerBillingConfig.bandwidthPackageId); setParameter(std::string("LoadBalancerBillingConfig") + ".InternetChargeType", loadBalancerBillingConfig.internetChargeType); setParameter(std::string("LoadBalancerBillingConfig") + ".InternetBandwidth", std::to_string(loadBalancerBillingConfig.internetBandwidth)); setParameter(std::string("LoadBalancerBillingConfig") + ".PayType", loadBalancerBillingConfig.payType); } +std::string CreateLoadBalancerRequest::getAddressIpVersion() const { + return addressIpVersion_; +} + +void CreateLoadBalancerRequest::setAddressIpVersion(const std::string &addressIpVersion) { + addressIpVersion_ = addressIpVersion; + setParameter(std::string("AddressIpVersion"), addressIpVersion); +} + bool CreateLoadBalancerRequest::getDeletionProtectionEnabled() const { return deletionProtectionEnabled_; } @@ -127,6 +137,7 @@ void CreateLoadBalancerRequest::setZoneMappings(const std::vector + +using AlibabaCloud::Alb::Model::DetachCommonBandwidthPackageFromLoadBalancerRequest; + +DetachCommonBandwidthPackageFromLoadBalancerRequest::DetachCommonBandwidthPackageFromLoadBalancerRequest() + : RpcServiceRequest("alb", "2020-06-16", "DetachCommonBandwidthPackageFromLoadBalancer") { + setMethod(HttpRequest::Method::Post); +} + +DetachCommonBandwidthPackageFromLoadBalancerRequest::~DetachCommonBandwidthPackageFromLoadBalancerRequest() {} + +std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getClientToken() const { + return clientToken_; +} + +void DetachCommonBandwidthPackageFromLoadBalancerRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getRegionId() const { + return regionId_; +} + +void DetachCommonBandwidthPackageFromLoadBalancerRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getBandwidthPackageId() const { + return bandwidthPackageId_; +} + +void DetachCommonBandwidthPackageFromLoadBalancerRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) { + bandwidthPackageId_ = bandwidthPackageId; + setParameter(std::string("BandwidthPackageId"), bandwidthPackageId); +} + +bool DetachCommonBandwidthPackageFromLoadBalancerRequest::getDryRun() const { + return dryRun_; +} + +void DetachCommonBandwidthPackageFromLoadBalancerRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getLoadBalancerId() const { + return loadBalancerId_; +} + +void DetachCommonBandwidthPackageFromLoadBalancerRequest::setLoadBalancerId(const std::string &loadBalancerId) { + loadBalancerId_ = loadBalancerId; + setParameter(std::string("LoadBalancerId"), loadBalancerId); +} + diff --git a/alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc b/alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc new file mode 100644 index 000000000..10f9c081c --- /dev/null +++ b/alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.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::Alb; +using namespace AlibabaCloud::Alb::Model; + +DetachCommonBandwidthPackageFromLoadBalancerResult::DetachCommonBandwidthPackageFromLoadBalancerResult() : + ServiceResult() +{} + +DetachCommonBandwidthPackageFromLoadBalancerResult::DetachCommonBandwidthPackageFromLoadBalancerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DetachCommonBandwidthPackageFromLoadBalancerResult::~DetachCommonBandwidthPackageFromLoadBalancerResult() +{} + +void DetachCommonBandwidthPackageFromLoadBalancerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["JobId"].isNull()) + jobId_ = value["JobId"].asString(); + +} + +std::string DetachCommonBandwidthPackageFromLoadBalancerResult::getJobId()const +{ + return jobId_; +} + diff --git a/alb/src/model/GetListenerHealthStatusRequest.cc b/alb/src/model/GetListenerHealthStatusRequest.cc new file mode 100644 index 000000000..92a9af310 --- /dev/null +++ b/alb/src/model/GetListenerHealthStatusRequest.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 + +using AlibabaCloud::Alb::Model::GetListenerHealthStatusRequest; + +GetListenerHealthStatusRequest::GetListenerHealthStatusRequest() + : RpcServiceRequest("alb", "2020-06-16", "GetListenerHealthStatus") { + setMethod(HttpRequest::Method::Post); +} + +GetListenerHealthStatusRequest::~GetListenerHealthStatusRequest() {} + +bool GetListenerHealthStatusRequest::getIncludeRule() const { + return includeRule_; +} + +void GetListenerHealthStatusRequest::setIncludeRule(bool includeRule) { + includeRule_ = includeRule; + setParameter(std::string("IncludeRule"), includeRule ? "true" : "false"); +} + +std::string GetListenerHealthStatusRequest::getListenerId() const { + return listenerId_; +} + +void GetListenerHealthStatusRequest::setListenerId(const std::string &listenerId) { + listenerId_ = listenerId; + setParameter(std::string("ListenerId"), listenerId); +} + +std::string GetListenerHealthStatusRequest::getNextToken() const { + return nextToken_; +} + +void GetListenerHealthStatusRequest::setNextToken(const std::string &nextToken) { + nextToken_ = nextToken; + setParameter(std::string("NextToken"), nextToken); +} + +long GetListenerHealthStatusRequest::getMaxResults() const { + return maxResults_; +} + +void GetListenerHealthStatusRequest::setMaxResults(long maxResults) { + maxResults_ = maxResults; + setParameter(std::string("MaxResults"), std::to_string(maxResults)); +} + diff --git a/alb/src/model/GetListenerHealthStatusResult.cc b/alb/src/model/GetListenerHealthStatusResult.cc new file mode 100644 index 000000000..f385b8a00 --- /dev/null +++ b/alb/src/model/GetListenerHealthStatusResult.cc @@ -0,0 +1,147 @@ +/* + * 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::Alb; +using namespace AlibabaCloud::Alb::Model; + +GetListenerHealthStatusResult::GetListenerHealthStatusResult() : + ServiceResult() +{} + +GetListenerHealthStatusResult::GetListenerHealthStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetListenerHealthStatusResult::~GetListenerHealthStatusResult() +{} + +void GetListenerHealthStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allListenerHealthStatusNode = value["ListenerHealthStatus"]["ListenerHealthStatusModel"]; + for (auto valueListenerHealthStatusListenerHealthStatusModel : allListenerHealthStatusNode) + { + ListenerHealthStatusModel listenerHealthStatusObject; + if(!valueListenerHealthStatusListenerHealthStatusModel["ListenerId"].isNull()) + listenerHealthStatusObject.listenerId = valueListenerHealthStatusListenerHealthStatusModel["ListenerId"].asString(); + if(!valueListenerHealthStatusListenerHealthStatusModel["ListenerPort"].isNull()) + listenerHealthStatusObject.listenerPort = std::stoi(valueListenerHealthStatusListenerHealthStatusModel["ListenerPort"].asString()); + if(!valueListenerHealthStatusListenerHealthStatusModel["ListenerProtocol"].isNull()) + listenerHealthStatusObject.listenerProtocol = valueListenerHealthStatusListenerHealthStatusModel["ListenerProtocol"].asString(); + auto allServerGroupInfosNode = valueListenerHealthStatusListenerHealthStatusModel["ServerGroupInfos"]["ServerGroupHealthStatusModel"]; + for (auto valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel : allServerGroupInfosNode) + { + ListenerHealthStatusModel::ServerGroupHealthStatusModel serverGroupInfosObject; + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].isNull()) + serverGroupInfosObject.healthCheckEnabled = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].asString(); + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].isNull()) + serverGroupInfosObject.serverGroupId = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].asString(); + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].isNull()) + serverGroupInfosObject.actionType = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].asString(); + auto allNonNormalServersNode = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["NonNormalServers"]["BackendServerHealthStatusModel"]; + for (auto valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel : allNonNormalServersNode) + { + ListenerHealthStatusModel::ServerGroupHealthStatusModel::BackendServerHealthStatusModel nonNormalServersObject; + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Port"].isNull()) + nonNormalServersObject.port = std::stoi(valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Port"].asString()); + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerId"].isNull()) + nonNormalServersObject.serverId = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerId"].asString(); + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerIp"].isNull()) + nonNormalServersObject.serverIp = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerIp"].asString(); + if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Status"].isNull()) + nonNormalServersObject.status = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Status"].asString(); + auto reasonNode = value["Reason"]; + if(!reasonNode["ActualResponse"].isNull()) + nonNormalServersObject.reason.actualResponse = reasonNode["ActualResponse"].asString(); + if(!reasonNode["ExpectedResponse"].isNull()) + nonNormalServersObject.reason.expectedResponse = reasonNode["ExpectedResponse"].asString(); + if(!reasonNode["ReasonCode"].isNull()) + nonNormalServersObject.reason.reasonCode = reasonNode["ReasonCode"].asString(); + serverGroupInfosObject.nonNormalServers.push_back(nonNormalServersObject); + } + listenerHealthStatusObject.serverGroupInfos.push_back(serverGroupInfosObject); + } + listenerHealthStatus_.push_back(listenerHealthStatusObject); + } + auto allRuleHealthStatusNode = value["RuleHealthStatus"]["RuleHealthStatusModel"]; + for (auto valueRuleHealthStatusRuleHealthStatusModel : allRuleHealthStatusNode) + { + RuleHealthStatusModel ruleHealthStatusObject; + if(!valueRuleHealthStatusRuleHealthStatusModel["RuleId"].isNull()) + ruleHealthStatusObject.ruleId = valueRuleHealthStatusRuleHealthStatusModel["RuleId"].asString(); + auto allServerGroupInfos1Node = valueRuleHealthStatusRuleHealthStatusModel["ServerGroupInfos"]["ServerGroupHealthStatusModel"]; + for (auto valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel : allServerGroupInfos1Node) + { + RuleHealthStatusModel::ServerGroupHealthStatusModel2 serverGroupInfos1Object; + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].isNull()) + serverGroupInfos1Object.healthCheckEnabled = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].asString(); + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].isNull()) + serverGroupInfos1Object.serverGroupId = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].asString(); + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].isNull()) + serverGroupInfos1Object.actionType = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].asString(); + auto allNonNormalServers3Node = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["NonNormalServers"]["NonNormalServer"]; + for (auto valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer : allNonNormalServers3Node) + { + RuleHealthStatusModel::ServerGroupHealthStatusModel2::NonNormalServer nonNormalServers3Object; + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Port"].isNull()) + nonNormalServers3Object.port = std::stoi(valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Port"].asString()); + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerId"].isNull()) + nonNormalServers3Object.serverId = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerId"].asString(); + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerIp"].isNull()) + nonNormalServers3Object.serverIp = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerIp"].asString(); + if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Status"].isNull()) + nonNormalServers3Object.status = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Status"].asString(); + auto reason4Node = value["Reason"]; + if(!reason4Node["ActualResponse"].isNull()) + nonNormalServers3Object.reason4.actualResponse = reason4Node["ActualResponse"].asString(); + if(!reason4Node["ExpectedResponse"].isNull()) + nonNormalServers3Object.reason4.expectedResponse = reason4Node["ExpectedResponse"].asString(); + if(!reason4Node["ReasonCode"].isNull()) + nonNormalServers3Object.reason4.reasonCode = reason4Node["ReasonCode"].asString(); + serverGroupInfos1Object.nonNormalServers3.push_back(nonNormalServers3Object); + } + ruleHealthStatusObject.serverGroupInfos1.push_back(serverGroupInfos1Object); + } + ruleHealthStatus_.push_back(ruleHealthStatusObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + +} + +std::vector GetListenerHealthStatusResult::getRuleHealthStatus()const +{ + return ruleHealthStatus_; +} + +std::vector GetListenerHealthStatusResult::getListenerHealthStatus()const +{ + return listenerHealthStatus_; +} + +std::string GetListenerHealthStatusResult::getNextToken()const +{ + return nextToken_; +} + diff --git a/alb/src/model/GetLoadBalancerAttributeResult.cc b/alb/src/model/GetLoadBalancerAttributeResult.cc index bfbb8bd51..2de72da1d 100644 --- a/alb/src/model/GetLoadBalancerAttributeResult.cc +++ b/alb/src/model/GetLoadBalancerAttributeResult.cc @@ -73,6 +73,8 @@ void GetLoadBalancerAttributeResult::parse(const std::string &payload) ZoneMapping::LoadBalancerAddress loadBalancerAddressesObject; if(!valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Address"].isNull()) loadBalancerAddressesObject.address = valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Address"].asString(); + if(!valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Ipv6Address"].isNull()) + loadBalancerAddressesObject.ipv6Address = valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Ipv6Address"].asString(); zoneMappingsObject.loadBalancerAddresses.push_back(loadBalancerAddressesObject); } zoneMappings_.push_back(zoneMappingsObject); @@ -134,6 +136,12 @@ void GetLoadBalancerAttributeResult::parse(const std::string &payload) resourceGroupId_ = value["ResourceGroupId"].asString(); if(!value["VpcId"].isNull()) vpcId_ = value["VpcId"].asString(); + if(!value["ConfigManagedEnabled"].isNull()) + configManagedEnabled_ = value["ConfigManagedEnabled"].asString() == "true"; + if(!value["AddressIpVersion"].isNull()) + addressIpVersion_ = value["AddressIpVersion"].asString(); + if(!value["Ipv6AddressType"].isNull()) + ipv6AddressType_ = value["Ipv6AddressType"].asString(); } @@ -142,9 +150,9 @@ bool GetLoadBalancerAttributeResult::getServiceManagedEnabled()const return serviceManagedEnabled_; } -std::string GetLoadBalancerAttributeResult::getLoadBalancerEdition()const +std::string GetLoadBalancerAttributeResult::getAddressIpVersion()const { - return loadBalancerEdition_; + return addressIpVersion_; } std::string GetLoadBalancerAttributeResult::getResourceGroupId()const @@ -152,21 +160,11 @@ std::string GetLoadBalancerAttributeResult::getResourceGroupId()const return resourceGroupId_; } -GetLoadBalancerAttributeResult::LoadBalancerBillingConfig GetLoadBalancerAttributeResult::getLoadBalancerBillingConfig()const -{ - return loadBalancerBillingConfig_; -} - std::vector GetLoadBalancerAttributeResult::getFeatureLabels()const { return featureLabels_; } -std::string GetLoadBalancerAttributeResult::getCreateTime()const -{ - return createTime_; -} - std::string GetLoadBalancerAttributeResult::getLoadBalancerId()const { return loadBalancerId_; @@ -182,6 +180,51 @@ std::string GetLoadBalancerAttributeResult::getDNSName()const return dNSName_; } +std::string GetLoadBalancerAttributeResult::getIpv6AddressType()const +{ + return ipv6AddressType_; +} + +int GetLoadBalancerAttributeResult::getBandwidthCapacity()const +{ + return bandwidthCapacity_; +} + +GetLoadBalancerAttributeResult::DeletionProtectionConfig GetLoadBalancerAttributeResult::getDeletionProtectionConfig()const +{ + return deletionProtectionConfig_; +} + +std::string GetLoadBalancerAttributeResult::getServiceManagedMode()const +{ + return serviceManagedMode_; +} + +std::string GetLoadBalancerAttributeResult::getBandwidthPackageId()const +{ + return bandwidthPackageId_; +} + +std::vector GetLoadBalancerAttributeResult::getTags()const +{ + return tags_; +} + +std::string GetLoadBalancerAttributeResult::getLoadBalancerEdition()const +{ + return loadBalancerEdition_; +} + +GetLoadBalancerAttributeResult::LoadBalancerBillingConfig GetLoadBalancerAttributeResult::getLoadBalancerBillingConfig()const +{ + return loadBalancerBillingConfig_; +} + +std::string GetLoadBalancerAttributeResult::getCreateTime()const +{ + return createTime_; +} + GetLoadBalancerAttributeResult::ModificationProtectionConfig GetLoadBalancerAttributeResult::getModificationProtectionConfig()const { return modificationProtectionConfig_; @@ -197,14 +240,9 @@ GetLoadBalancerAttributeResult::AccessLogConfig GetLoadBalancerAttributeResult:: return accessLogConfig_; } -int GetLoadBalancerAttributeResult::getBandwidthCapacity()const +bool GetLoadBalancerAttributeResult::getConfigManagedEnabled()const { - return bandwidthCapacity_; -} - -GetLoadBalancerAttributeResult::DeletionProtectionConfig GetLoadBalancerAttributeResult::getDeletionProtectionConfig()const -{ - return deletionProtectionConfig_; + return configManagedEnabled_; } std::string GetLoadBalancerAttributeResult::getLoadBalancerBussinessStatus()const @@ -217,16 +255,6 @@ std::string GetLoadBalancerAttributeResult::getVpcId()const return vpcId_; } -std::string GetLoadBalancerAttributeResult::getServiceManagedMode()const -{ - return serviceManagedMode_; -} - -std::string GetLoadBalancerAttributeResult::getBandwidthPackageId()const -{ - return bandwidthPackageId_; -} - std::string GetLoadBalancerAttributeResult::getRegionId()const { return regionId_; @@ -247,11 +275,6 @@ std::string GetLoadBalancerAttributeResult::getLoadBalancerStatus()const return loadBalancerStatus_; } -std::vector GetLoadBalancerAttributeResult::getTags()const -{ - return tags_; -} - std::vector GetLoadBalancerAttributeResult::getLoadBalancerOperationLocks()const { return loadBalancerOperationLocks_; diff --git a/alb/src/model/ListAclsResult.cc b/alb/src/model/ListAclsResult.cc index d80cf0d97..6b24836cf 100644 --- a/alb/src/model/ListAclsResult.cc +++ b/alb/src/model/ListAclsResult.cc @@ -57,6 +57,8 @@ void ListAclsResult::parse(const std::string &payload) aclsObject.serviceManagedEnabled = valueAclsAcl["ServiceManagedEnabled"].asString() == "true"; if(!valueAclsAcl["ServiceManagedMode"].isNull()) aclsObject.serviceManagedMode = valueAclsAcl["ServiceManagedMode"].asString(); + if(!valueAclsAcl["ConfigManagedEnabled"].isNull()) + aclsObject.configManagedEnabled = valueAclsAcl["ConfigManagedEnabled"].asString() == "true"; acls_.push_back(aclsObject); } if(!value["MaxResults"].isNull()) diff --git a/alb/src/model/ListLoadBalancersRequest.cc b/alb/src/model/ListLoadBalancersRequest.cc index 1ee0cf1ce..39fadb466 100644 --- a/alb/src/model/ListLoadBalancersRequest.cc +++ b/alb/src/model/ListLoadBalancersRequest.cc @@ -47,6 +47,15 @@ void ListLoadBalancersRequest::setLoadBalancerIds(const std::vector ReplaceServersInSe void ReplaceServersInServerGroupRequest::setAddedServers(const std::vector &addedServers) { addedServers_ = addedServers; for(int dep1 = 0; dep1 != addedServers.size(); dep1++) { + setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".RemoteIpEnabled", addedServers[dep1].remoteIpEnabled ? "true" : "false"); setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".ServerType", addedServers[dep1].serverType); setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".Port", std::to_string(addedServers[dep1].port)); setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".Description", addedServers[dep1].description); diff --git a/alb/src/model/UpdateLoadBalancerZonesRequest.cc b/alb/src/model/UpdateLoadBalancerZonesRequest.cc new file mode 100644 index 000000000..e4b3cd150 --- /dev/null +++ b/alb/src/model/UpdateLoadBalancerZonesRequest.cc @@ -0,0 +1,67 @@ +/* + * 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::Alb::Model::UpdateLoadBalancerZonesRequest; + +UpdateLoadBalancerZonesRequest::UpdateLoadBalancerZonesRequest() + : RpcServiceRequest("alb", "2020-06-16", "UpdateLoadBalancerZones") { + setMethod(HttpRequest::Method::Post); +} + +UpdateLoadBalancerZonesRequest::~UpdateLoadBalancerZonesRequest() {} + +std::string UpdateLoadBalancerZonesRequest::getClientToken() const { + return clientToken_; +} + +void UpdateLoadBalancerZonesRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +bool UpdateLoadBalancerZonesRequest::getDryRun() const { + return dryRun_; +} + +void UpdateLoadBalancerZonesRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::vector UpdateLoadBalancerZonesRequest::getZoneMappings() const { + return zoneMappings_; +} + +void UpdateLoadBalancerZonesRequest::setZoneMappings(const std::vector &zoneMappings) { + zoneMappings_ = zoneMappings; + for(int dep1 = 0; dep1 != zoneMappings.size(); dep1++) { + setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".VSwitchId", zoneMappings[dep1].vSwitchId); + setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".ZoneId", zoneMappings[dep1].zoneId); + setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".AllocationId", zoneMappings[dep1].allocationId); + } +} + +std::string UpdateLoadBalancerZonesRequest::getLoadBalancerId() const { + return loadBalancerId_; +} + +void UpdateLoadBalancerZonesRequest::setLoadBalancerId(const std::string &loadBalancerId) { + loadBalancerId_ = loadBalancerId; + setParameter(std::string("LoadBalancerId"), loadBalancerId); +} + diff --git a/alb/src/model/UpdateLoadBalancerZonesResult.cc b/alb/src/model/UpdateLoadBalancerZonesResult.cc new file mode 100644 index 000000000..7782869ed --- /dev/null +++ b/alb/src/model/UpdateLoadBalancerZonesResult.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::Alb; +using namespace AlibabaCloud::Alb::Model; + +UpdateLoadBalancerZonesResult::UpdateLoadBalancerZonesResult() : + ServiceResult() +{} + +UpdateLoadBalancerZonesResult::UpdateLoadBalancerZonesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateLoadBalancerZonesResult::~UpdateLoadBalancerZonesResult() +{} + +void UpdateLoadBalancerZonesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["JobId"].isNull()) + jobId_ = value["JobId"].asString(); + +} + +std::string UpdateLoadBalancerZonesResult::getJobId()const +{ + return jobId_; +} + diff --git a/alb/src/model/UpdateServerGroupAttributeRequest.cc b/alb/src/model/UpdateServerGroupAttributeRequest.cc index 41fa09229..78d8edca0 100644 --- a/alb/src/model/UpdateServerGroupAttributeRequest.cc +++ b/alb/src/model/UpdateServerGroupAttributeRequest.cc @@ -87,6 +87,15 @@ void UpdateServerGroupAttributeRequest::setServerGroupId(const std::string &serv setParameter(std::string("ServerGroupId"), serverGroupId); } +bool UpdateServerGroupAttributeRequest::getUpstreamKeepaliveEnabled() const { + return upstreamKeepaliveEnabled_; +} + +void UpdateServerGroupAttributeRequest::setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled) { + upstreamKeepaliveEnabled_ = upstreamKeepaliveEnabled; + setParameter(std::string("UpstreamKeepaliveEnabled"), upstreamKeepaliveEnabled ? "true" : "false"); +} + UpdateServerGroupAttributeRequest::StickySessionConfig UpdateServerGroupAttributeRequest::getStickySessionConfig() const { return stickySessionConfig_; }