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

Support health check paging.

Browse Source
This commit is contained in:
sdk-team
2021-11-30 02:41:43 +00:00
parent fe11ae7d12
commit cf984bbcfc
47 changed files with 1698 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
alb/CMakeLists.txt
View File

@@ -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

40
alb/include/alibabacloud/alb/AlbClient.h
View File

@@ -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<Error, Model::AddServersToServerGroupResult> AddServersToServerGroupOutcome;
typedef std::future<AddServersToServerGroupOutcome> AddServersToServerGroupOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::AddServersToServerGroupRequest&, const AddServersToServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddServersToServerGroupAsyncHandler;
typedef Outcome<Error, Model::ApplyHealthCheckTemplateToServerGroupResult> ApplyHealthCheckTemplateToServerGroupOutcome;
typedef std::future<ApplyHealthCheckTemplateToServerGroupOutcome> ApplyHealthCheckTemplateToServerGroupOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::ApplyHealthCheckTemplateToServerGroupRequest&, const ApplyHealthCheckTemplateToServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyHealthCheckTemplateToServerGroupAsyncHandler;
typedef Outcome<Error, Model::AssociateAclsWithListenerResult> AssociateAclsWithListenerOutcome;
typedef std::future<AssociateAclsWithListenerOutcome> AssociateAclsWithListenerOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::AssociateAclsWithListenerRequest&, const AssociateAclsWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAclsWithListenerAsyncHandler;
typedef Outcome<Error, Model::AssociateAdditionalCertificatesWithListenerResult> AssociateAdditionalCertificatesWithListenerOutcome;
typedef std::future<AssociateAdditionalCertificatesWithListenerOutcome> AssociateAdditionalCertificatesWithListenerOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::AssociateAdditionalCertificatesWithListenerRequest&, const AssociateAdditionalCertificatesWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAdditionalCertificatesWithListenerAsyncHandler;
typedef Outcome<Error, Model::AttachCommonBandwidthPackageToLoadBalancerResult> AttachCommonBandwidthPackageToLoadBalancerOutcome;
typedef std::future<AttachCommonBandwidthPackageToLoadBalancerOutcome> AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::AttachCommonBandwidthPackageToLoadBalancerRequest&, const AttachCommonBandwidthPackageToLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachCommonBandwidthPackageToLoadBalancerAsyncHandler;
typedef Outcome<Error, Model::CreateAclResult> CreateAclOutcome;
typedef std::future<CreateAclOutcome> CreateAclOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::CreateAclRequest&, const CreateAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAclAsyncHandler;
@@ -231,6 +247,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
typedef Outcome<Error, Model::DetachCommonBandwidthPackageFromLoadBalancerResult> DetachCommonBandwidthPackageFromLoadBalancerOutcome;
typedef std::future<DetachCommonBandwidthPackageFromLoadBalancerOutcome> DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest&, const DetachCommonBandwidthPackageFromLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler;
typedef Outcome<Error, Model::DisableDeletionProtectionResult> DisableDeletionProtectionOutcome;
typedef std::future<DisableDeletionProtectionOutcome> DisableDeletionProtectionOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::DisableDeletionProtectionRequest&, const DisableDeletionProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDeletionProtectionAsyncHandler;
@@ -255,6 +274,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetListenerAttributeResult> GetListenerAttributeOutcome;
typedef std::future<GetListenerAttributeOutcome> GetListenerAttributeOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::GetListenerAttributeRequest&, const GetListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::GetListenerHealthStatusResult> GetListenerHealthStatusOutcome;
typedef std::future<GetListenerHealthStatusOutcome> GetListenerHealthStatusOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::GetListenerHealthStatusRequest&, const GetListenerHealthStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerHealthStatusAsyncHandler;
typedef Outcome<Error, Model::GetLoadBalancerAttributeResult> GetLoadBalancerAttributeOutcome;
typedef std::future<GetLoadBalancerAttributeOutcome> GetLoadBalancerAttributeOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::GetLoadBalancerAttributeRequest&, const GetLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLoadBalancerAttributeAsyncHandler;
@@ -351,6 +373,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateLoadBalancerEditionResult> UpdateLoadBalancerEditionOutcome;
typedef std::future<UpdateLoadBalancerEditionOutcome> UpdateLoadBalancerEditionOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerEditionRequest&, const UpdateLoadBalancerEditionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerEditionAsyncHandler;
typedef Outcome<Error, Model::UpdateLoadBalancerZonesResult> UpdateLoadBalancerZonesOutcome;
typedef std::future<UpdateLoadBalancerZonesOutcome> UpdateLoadBalancerZonesOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerZonesRequest&, const UpdateLoadBalancerZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerZonesAsyncHandler;
typedef Outcome<Error, Model::UpdateRuleAttributeResult> UpdateRuleAttributeOutcome;
typedef std::future<UpdateRuleAttributeOutcome> UpdateRuleAttributeOutcomeCallable;
typedef std::function<void(const AlbClient*, const Model::UpdateRuleAttributeRequest&, const UpdateRuleAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
UpdateRuleAttributeOutcomeCallable updateRuleAttributeCallable(const Model::UpdateRuleAttributeRequest& request) const;

1
alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h
View File

@@ -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;

51
alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_
#include <alibabacloud/alb/AlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

51
alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_
#define ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/alb/AlbExport.h>
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_

54
alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_
#define ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_
#include <alibabacloud/alb/AlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

51
alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_
#define ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/alb/AlbExport.h>
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_

5
alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h
View File

@@ -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_;

6
alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h
View File

@@ -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_;
};

54
alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_
#define ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_
#include <alibabacloud/alb/AlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 &regionId);
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_

51
alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_
#define ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/alb/AlbExport.h>
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_

51
alb/include/alibabacloud/alb/model/GetListenerHealthStatusRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_
#define ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_
#include <alibabacloud/alb/AlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

109
alb/include/alibabacloud/alb/model/GetListenerHealthStatusResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/alb/AlbExport.h>
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<ServerGroupHealthStatusModel::BackendServerHealthStatusModel> nonNormalServers;
std::string serverGroupId;
std::string healthCheckEnabled;
};
int listenerPort;
std::vector<ListenerHealthStatusModel::ServerGroupHealthStatusModel> 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<ServerGroupHealthStatusModel2::NonNormalServer> nonNormalServers3;
};
std::vector<RuleHealthStatusModel::ServerGroupHealthStatusModel2> serverGroupInfos1;
std::string ruleId;
};
GetListenerHealthStatusResult();
explicit GetListenerHealthStatusResult(const std::string &payload);
~GetListenerHealthStatusResult();
std::vector<RuleHealthStatusModel> getRuleHealthStatus()const;
std::vector<ListenerHealthStatusModel> getListenerHealthStatus()const;
std::string getNextToken()const;
protected:
void parse(const std::string &payload);
private:
std::vector<RuleHealthStatusModel> ruleHealthStatus_;
std::vector<ListenerHealthStatusModel> listenerHealthStatus_;
std::string nextToken_;
};
}
}
}
#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_

39
alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h
View File

@@ -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<std::string> getFeatureLabels()const;
std::string getCreateTime()const;
std::string getLoadBalancerId()const;
std::vector<ZoneMapping> 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<Tag> 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<Tag> getTags()const;
std::vector<LoadBalancerOperationLock> 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<std::string> featureLabels_;
std::string createTime_;
std::string loadBalancerId_;
std::vector<ZoneMapping> zoneMappings_;
std::string dNSName_;
std::string ipv6AddressType_;
int bandwidthCapacity_;
DeletionProtectionConfig deletionProtectionConfig_;
std::string serviceManagedMode_;
std::string bandwidthPackageId_;
std::vector<Tag> 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<Tag> tags_;
std::vector<LoadBalancerOperationLock> loadBalancerOperationLocks_;
};

1
alb/include/alibabacloud/alb/model/ListAclsResult.h
View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct Acl
{
bool serviceManagedEnabled;
bool configManagedEnabled;
std::string aclStatus;
std::string resourceGroupId;
std::string aclId;

6
alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h
View File

@@ -38,6 +38,8 @@ public:
void setLoadBalancerNames(const std::vector<std::string> &loadBalancerNames);
std::vector<std::string> getLoadBalancerIds() const;
void setLoadBalancerIds(const std::vector<std::string> &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<std::string> loadBalancerNames_;
std::vector<std::string> 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

3
alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h
View File

@@ -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;

1
alb/include/alibabacloud/alb/model/ListServerGroupServersResult.h
View File

@@ -40,6 +40,7 @@ namespace AlibabaCloud
std::string serverId;
int port;
std::string serverIp;
bool remoteIpEnabled;
std::string serverGroupId;
int weight;
};

4
alb/include/alibabacloud/alb/model/ListServerGroupsResult.h
View File

@@ -67,10 +67,14 @@ namespace AlibabaCloud
std::vector<std::string> 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;

1
alb/include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h
View File

@@ -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;

56
alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h Normal file
View File

@@ -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 <alibabacloud/alb/AlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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<ZoneMappings> getZoneMappings() const;
void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string clientToken_;
bool dryRun_;
std::vector<ZoneMappings> zoneMappings_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Alb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_

51
alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_
#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/alb/AlbExport.h>
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_

3
alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h
View File

@@ -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_;
};

180
alb/src/AlbClient.cc
View File

@@ -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<const AsyncCallerContext>& 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<std::packaged_task<ApplyHealthCheckTemplateToServerGroupOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<AttachCommonBandwidthPackageToLoadBalancerOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<DetachCommonBandwidthPackageFromLoadBalancerOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<GetListenerHealthStatusOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<UpdateLoadBalancerZonesOutcome()>>(
[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();

1
alb/src/model/AddServersToServerGroupRequest.cc
View File

@@ -50,6 +50,7 @@ std::vector<AddServersToServerGroupRequest::Servers> AddServersToServerGroupRequ
void AddServersToServerGroupRequest::setServers(const std::vector<AddServersToServerGroupRequest::Servers> &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);

63
alb/src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h>
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);
}

51
alb/src/model/ApplyHealthCheckTemplateToServerGroupResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h>
#include <json/json.h>
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_;
}

72
alb/src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h>
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 &regionId) {
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);
}

51
alb/src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h>
#include <json/json.h>
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_;
}

11
alb/src/model/CreateLoadBalancerRequest.cc
View File

@@ -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<CreateLoadBala
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);
}
}

18
alb/src/model/CreateServerGroupRequest.cc
View File

@@ -96,6 +96,15 @@ void CreateServerGroupRequest::setProtocol(const std::string &protocol) {
setParameter(std::string("Protocol"), protocol);
}
bool CreateServerGroupRequest::getUpstreamKeepaliveEnabled() const {
return upstreamKeepaliveEnabled_;
}
void CreateServerGroupRequest::setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled) {
upstreamKeepaliveEnabled_ = upstreamKeepaliveEnabled;
setParameter(std::string("UpstreamKeepaliveEnabled"), upstreamKeepaliveEnabled ? "true" : "false");
}
CreateServerGroupRequest::StickySessionConfig CreateServerGroupRequest::getStickySessionConfig() const {
return stickySessionConfig_;
}
@@ -117,6 +126,15 @@ void CreateServerGroupRequest::setDryRun(bool dryRun) {
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
bool CreateServerGroupRequest::getIpv6Enabled() const {
return ipv6Enabled_;
}
void CreateServerGroupRequest::setIpv6Enabled(bool ipv6Enabled) {
ipv6Enabled_ = ipv6Enabled;
setParameter(std::string("Ipv6Enabled"), ipv6Enabled ? "true" : "false");
}
std::string CreateServerGroupRequest::getServerGroupType() const {
return serverGroupType_;
}

72
alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h>
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 &regionId) {
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);
}

51
alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h>
#include <json/json.h>
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_;
}

63
alb/src/model/GetListenerHealthStatusRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/GetListenerHealthStatusRequest.h>
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));
}

147
alb/src/model/GetListenerHealthStatusResult.cc Normal file
View File

@@ -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 <alibabacloud/alb/model/GetListenerHealthStatusResult.h>
#include <json/json.h>
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::RuleHealthStatusModel> GetListenerHealthStatusResult::getRuleHealthStatus()const
{
return ruleHealthStatus_;
}
std::vector<GetListenerHealthStatusResult::ListenerHealthStatusModel> GetListenerHealthStatusResult::getListenerHealthStatus()const
{
return listenerHealthStatus_;
}
std::string GetListenerHealthStatusResult::getNextToken()const
{
return nextToken_;
}

91
alb/src/model/GetLoadBalancerAttributeResult.cc
View File

@@ -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<std::string> 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::Tag> 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::Tag> GetLoadBalancerAttributeResult::getTags()const
{
return tags_;
}
std::vector<GetLoadBalancerAttributeResult::LoadBalancerOperationLock> GetLoadBalancerAttributeResult::getLoadBalancerOperationLocks()const
{
return loadBalancerOperationLocks_;

2
alb/src/model/ListAclsResult.cc
View File

@@ -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())

18
alb/src/model/ListLoadBalancersRequest.cc
View File

@@ -47,6 +47,15 @@ void ListLoadBalancersRequest::setLoadBalancerIds(const std::vector<ListLoadBala
}
}
std::string ListLoadBalancersRequest::getAddressIpVersion() const {
return addressIpVersion_;
}
void ListLoadBalancersRequest::setAddressIpVersion(const std::string &addressIpVersion) {
addressIpVersion_ = addressIpVersion;
setParameter(std::string("AddressIpVersion"), addressIpVersion);
}
std::string ListLoadBalancersRequest::getResourceGroupId() const {
return resourceGroupId_;
}
@@ -151,6 +160,15 @@ void ListLoadBalancersRequest::setZoneId(const std::string &zoneId) {
setParameter(std::string("ZoneId"), zoneId);
}
std::string ListLoadBalancersRequest::getIpv6AddressType() const {
return ipv6AddressType_;
}
void ListLoadBalancersRequest::setIpv6AddressType(const std::string &ipv6AddressType) {
ipv6AddressType_ = ipv6AddressType;
setParameter(std::string("Ipv6AddressType"), ipv6AddressType);
}
std::string ListLoadBalancersRequest::getPayType() const {
return payType_;
}

6
alb/src/model/ListLoadBalancersResult.cc
View File

@@ -73,6 +73,12 @@ void ListLoadBalancersResult::parse(const std::string &payload)
loadBalancersObject.resourceGroupId = valueLoadBalancersloadBalancer["ResourceGroupId"].asString();
if(!valueLoadBalancersloadBalancer["VpcId"].isNull())
loadBalancersObject.vpcId = valueLoadBalancersloadBalancer["VpcId"].asString();
if(!valueLoadBalancersloadBalancer["ConfigManagedEnabled"].isNull())
loadBalancersObject.configManagedEnabled = valueLoadBalancersloadBalancer["ConfigManagedEnabled"].asString() == "true";
if(!valueLoadBalancersloadBalancer["AddressIpVersion"].isNull())
loadBalancersObject.addressIpVersion = valueLoadBalancersloadBalancer["AddressIpVersion"].asString();
if(!valueLoadBalancersloadBalancer["Ipv6AddressType"].isNull())
loadBalancersObject.ipv6AddressType = valueLoadBalancersloadBalancer["Ipv6AddressType"].asString();
auto allLoadBalancerOperationLocksNode = valueLoadBalancersloadBalancer["LoadBalancerOperationLocks"]["LoadBalancerOperationLock"];
for (auto valueLoadBalancersloadBalancerLoadBalancerOperationLocksLoadBalancerOperationLock : allLoadBalancerOperationLocksNode)
{

2
alb/src/model/ListServerGroupServersResult.cc
View File

@@ -59,6 +59,8 @@ void ListServerGroupServersResult::parse(const std::string &payload)
serversObject.weight = std::stoi(valueServersBackendServer["Weight"].asString());
if(!valueServersBackendServer["ServerGroupId"].isNull())
serversObject.serverGroupId = valueServersBackendServer["ServerGroupId"].asString();
if(!valueServersBackendServer["RemoteIpEnabled"].isNull())
serversObject.remoteIpEnabled = valueServersBackendServer["RemoteIpEnabled"].asString() == "true";
servers_.push_back(serversObject);
}
if(!value["MaxResults"].isNull())

8
alb/src/model/ListServerGroupsResult.cc
View File

@@ -63,6 +63,14 @@ void ListServerGroupsResult::parse(const std::string &payload)
serverGroupsObject.serviceManagedEnabled = valueServerGroupsServerGroup["ServiceManagedEnabled"].asString() == "true";
if(!valueServerGroupsServerGroup["ServiceManagedMode"].isNull())
serverGroupsObject.serviceManagedMode = valueServerGroupsServerGroup["ServiceManagedMode"].asString();
if(!valueServerGroupsServerGroup["ConfigManagedEnabled"].isNull())
serverGroupsObject.configManagedEnabled = valueServerGroupsServerGroup["ConfigManagedEnabled"].asString() == "true";
if(!valueServerGroupsServerGroup["UpstreamKeepaliveEnabled"].isNull())
serverGroupsObject.upstreamKeepaliveEnabled = valueServerGroupsServerGroup["UpstreamKeepaliveEnabled"].asString() == "true";
if(!valueServerGroupsServerGroup["Ipv6Enabled"].isNull())
serverGroupsObject.ipv6Enabled = valueServerGroupsServerGroup["Ipv6Enabled"].asString() == "true";
if(!valueServerGroupsServerGroup["ServerCount"].isNull())
serverGroupsObject.serverCount = std::stoi(valueServerGroupsServerGroup["ServerCount"].asString());
auto allTagsNode = valueServerGroupsServerGroup["Tags"]["Tag"];
for (auto valueServerGroupsServerGroupTagsTag : allTagsNode)
{

1
alb/src/model/ReplaceServersInServerGroupRequest.cc
View File

@@ -50,6 +50,7 @@ std::vector<ReplaceServersInServerGroupRequest::AddedServers> ReplaceServersInSe
void ReplaceServersInServerGroupRequest::setAddedServers(const std::vector<ReplaceServersInServerGroupRequest::AddedServers> &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);

67
alb/src/model/UpdateLoadBalancerZonesRequest.cc Normal file
View File

@@ -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 <alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h>
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::ZoneMappings> UpdateLoadBalancerZonesRequest::getZoneMappings() const {
return zoneMappings_;
}
void UpdateLoadBalancerZonesRequest::setZoneMappings(const std::vector<UpdateLoadBalancerZonesRequest::ZoneMappings> &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);
}

51
alb/src/model/UpdateLoadBalancerZonesResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h>
#include <json/json.h>
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_;
}

9
alb/src/model/UpdateServerGroupAttributeRequest.cc
View File

@@ -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_;
}