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

SLB SDK Auto Released By laysong.sl,Version：1.23.4

Browse Source 
Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>
This commit is contained in:
yixiong.jxy
2018-08-28 16:48:49 +08:00
parent db4f78e6de
commit 84adbb2cb8
165 changed files with 9670 additions and 2918 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2018-08-28 Version: 1.23.4
1, Add param for DescribeRegions,support AcceptLanguage,RegionEndpoint.
2018-08-27 Version: 1.23.3
1, add Ess alarm task api, CreateAlarm, DeleteAlarm, DescribeAlarms, DeleteAlarm, EnableAlarm, DisableAlarm

2
VERSION
View File

@@ -1 +1 @@
1.23.3
1.23.4

52
slb/CMakeLists.txt
View File

@@ -21,6 +21,8 @@ set(slb_public_header
include/alibabacloud/slb/SlbExport.h )
set(slb_public_header_model
include/alibabacloud/slb/model/SetDomainExtensionAttributeRequest.h
include/alibabacloud/slb/model/SetDomainExtensionAttributeResult.h
include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h
@@ -53,6 +55,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/CreateLoadBalancerResult.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeDomainExtensionsRequest.h
include/alibabacloud/slb/model/DescribeDomainExtensionsResult.h
include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeResult.h
include/alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h
@@ -63,6 +67,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/DescribeZonesResult.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h
include/alibabacloud/slb/model/SetAutoRenewStatusRequest.h
include/alibabacloud/slb/model/SetAutoRenewStatusResult.h
include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h
include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h
include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h
@@ -87,8 +93,12 @@ set(slb_public_header_model
include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h
include/alibabacloud/slb/model/RemoveBackendServersRequest.h
include/alibabacloud/slb/model/RemoveBackendServersResult.h
include/alibabacloud/slb/model/AddAccessControlListEntryRequest.h
include/alibabacloud/slb/model/AddAccessControlListEntryResult.h
include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h
include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h
include/alibabacloud/slb/model/DescribeSlbQuotasRequest.h
include/alibabacloud/slb/model/DescribeSlbQuotasResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h
include/alibabacloud/slb/model/DeleteRulesRequest.h
@@ -101,6 +111,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h
include/alibabacloud/slb/model/SetBackendServersRequest.h
include/alibabacloud/slb/model/SetBackendServersResult.h
include/alibabacloud/slb/model/DeleteAccessControlListRequest.h
include/alibabacloud/slb/model/DeleteAccessControlListResult.h
include/alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h
include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h
@@ -111,8 +123,16 @@ set(slb_public_header_model
include/alibabacloud/slb/model/SetServerCertificateNameResult.h
include/alibabacloud/slb/model/DeleteCACertificateRequest.h
include/alibabacloud/slb/model/DeleteCACertificateResult.h
include/alibabacloud/slb/model/SetAccessControlListAttributeRequest.h
include/alibabacloud/slb/model/SetAccessControlListAttributeResult.h
include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h
include/alibabacloud/slb/model/DescribeAccessControlListAttributeRequest.h
include/alibabacloud/slb/model/DescribeAccessControlListAttributeResult.h
include/alibabacloud/slb/model/DescribeAccessControlListsRequest.h
include/alibabacloud/slb/model/DescribeAccessControlListsResult.h
include/alibabacloud/slb/model/DeleteDomainExtensionRequest.h
include/alibabacloud/slb/model/DeleteDomainExtensionResult.h
include/alibabacloud/slb/model/SetRuleRequest.h
include/alibabacloud/slb/model/SetRuleResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h
@@ -131,6 +151,10 @@ set(slb_public_header_model
include/alibabacloud/slb/model/DescribeServerCertificatesResult.h
include/alibabacloud/slb/model/DescribeRulesRequest.h
include/alibabacloud/slb/model/DescribeRulesResult.h
include/alibabacloud/slb/model/RemoveAccessControlListEntryRequest.h
include/alibabacloud/slb/model/RemoveAccessControlListEntryResult.h
include/alibabacloud/slb/model/CreateDomainExtensionRequest.h
include/alibabacloud/slb/model/CreateDomainExtensionResult.h
include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h
include/alibabacloud/slb/model/DescribeRuleAttributeResult.h
include/alibabacloud/slb/model/UploadServerCertificateRequest.h
@@ -145,6 +169,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h
include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h
include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h
include/alibabacloud/slb/model/CreateAccessControlListRequest.h
include/alibabacloud/slb/model/CreateAccessControlListResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h
@@ -164,6 +190,8 @@ set(slb_public_header_model
set(slb_src
src/SlbClient.cc
src/model/SetDomainExtensionAttributeRequest.cc
src/model/SetDomainExtensionAttributeResult.cc
src/model/CreateLoadBalancerUDPListenerRequest.cc
src/model/CreateLoadBalancerUDPListenerResult.cc
src/model/DescribeMasterSlaveVServerGroupsRequest.cc
@@ -196,6 +224,8 @@ set(slb_src
src/model/CreateLoadBalancerResult.cc
src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc
src/model/SetLoadBalancerHTTPListenerAttributeResult.cc
src/model/DescribeDomainExtensionsRequest.cc
src/model/DescribeDomainExtensionsResult.cc
src/model/SetLoadBalancerAutoReleaseTimeRequest.cc
src/model/SetLoadBalancerAutoReleaseTimeResult.cc
src/model/SetListenerAccessControlStatusRequest.cc
@@ -206,6 +236,8 @@ set(slb_src
src/model/DescribeZonesResult.cc
src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc
src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc
src/model/SetAutoRenewStatusRequest.cc
src/model/SetAutoRenewStatusResult.cc
src/model/DeleteLoadBalancerListenerRequest.cc
src/model/DeleteLoadBalancerListenerResult.cc
src/model/DescribeVServerGroupsRequest.cc
@@ -230,8 +262,12 @@ set(slb_src
src/model/CreateLoadBalancerHTTPListenerResult.cc
src/model/RemoveBackendServersRequest.cc
src/model/RemoveBackendServersResult.cc
src/model/AddAccessControlListEntryRequest.cc
src/model/AddAccessControlListEntryResult.cc
src/model/ModifyVServerGroupBackendServersRequest.cc
src/model/ModifyVServerGroupBackendServersResult.cc
src/model/DescribeSlbQuotasRequest.cc
src/model/DescribeSlbQuotasResult.cc
src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc
src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc
src/model/DeleteRulesRequest.cc
@@ -244,6 +280,8 @@ set(slb_src
src/model/CreateMasterSlaveVServerGroupResult.cc
src/model/SetBackendServersRequest.cc
src/model/SetBackendServersResult.cc
src/model/DeleteAccessControlListRequest.cc
src/model/DeleteAccessControlListResult.cc
src/model/RemoveVServerGroupBackendServersRequest.cc
src/model/RemoveVServerGroupBackendServersResult.cc
src/model/DescribeLoadBalancerAttributeRequest.cc
@@ -254,8 +292,16 @@ set(slb_src
src/model/SetServerCertificateNameResult.cc
src/model/DeleteCACertificateRequest.cc
src/model/DeleteCACertificateResult.cc
src/model/SetAccessControlListAttributeRequest.cc
src/model/SetAccessControlListAttributeResult.cc
src/model/CreateLoadBalancerTCPListenerRequest.cc
src/model/CreateLoadBalancerTCPListenerResult.cc
src/model/DescribeAccessControlListAttributeRequest.cc
src/model/DescribeAccessControlListAttributeResult.cc
src/model/DescribeAccessControlListsRequest.cc
src/model/DescribeAccessControlListsResult.cc
src/model/DeleteDomainExtensionRequest.cc
src/model/DeleteDomainExtensionResult.cc
src/model/SetRuleRequest.cc
src/model/SetRuleResult.cc
src/model/DescribeMasterSlaveServerGroupsRequest.cc
@@ -274,6 +320,10 @@ set(slb_src
src/model/DescribeServerCertificatesResult.cc
src/model/DescribeRulesRequest.cc
src/model/DescribeRulesResult.cc
src/model/RemoveAccessControlListEntryRequest.cc
src/model/RemoveAccessControlListEntryResult.cc
src/model/CreateDomainExtensionRequest.cc
src/model/CreateDomainExtensionResult.cc
src/model/DescribeRuleAttributeRequest.cc
src/model/DescribeRuleAttributeResult.cc
src/model/UploadServerCertificateRequest.cc
@@ -288,6 +338,8 @@ set(slb_src
src/model/SetVServerGroupAttributeResult.cc
src/model/ModifyLoadBalancerInternetSpecRequest.cc
src/model/ModifyLoadBalancerInternetSpecResult.cc
src/model/CreateAccessControlListRequest.cc
src/model/CreateAccessControlListResult.cc
src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc
src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc

104
slb/include/alibabacloud/slb/SlbClient.h
View File

@@ -22,6 +22,8 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "SlbExport.h"
#include "model/SetDomainExtensionAttributeRequest.h"
#include "model/SetDomainExtensionAttributeResult.h"
#include "model/CreateLoadBalancerUDPListenerRequest.h"
#include "model/CreateLoadBalancerUDPListenerResult.h"
#include "model/DescribeMasterSlaveVServerGroupsRequest.h"
@@ -54,6 +56,8 @@
#include "model/CreateLoadBalancerResult.h"
#include "model/SetLoadBalancerHTTPListenerAttributeRequest.h"
#include "model/SetLoadBalancerHTTPListenerAttributeResult.h"
#include "model/DescribeDomainExtensionsRequest.h"
#include "model/DescribeDomainExtensionsResult.h"
#include "model/SetLoadBalancerAutoReleaseTimeRequest.h"
#include "model/SetLoadBalancerAutoReleaseTimeResult.h"
#include "model/SetListenerAccessControlStatusRequest.h"
@@ -64,6 +68,8 @@
#include "model/DescribeZonesResult.h"
#include "model/SetLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/SetLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/SetAutoRenewStatusRequest.h"
#include "model/SetAutoRenewStatusResult.h"
#include "model/DeleteLoadBalancerListenerRequest.h"
#include "model/DeleteLoadBalancerListenerResult.h"
#include "model/DescribeVServerGroupsRequest.h"
@@ -88,8 +94,12 @@
#include "model/CreateLoadBalancerHTTPListenerResult.h"
#include "model/RemoveBackendServersRequest.h"
#include "model/RemoveBackendServersResult.h"
#include "model/AddAccessControlListEntryRequest.h"
#include "model/AddAccessControlListEntryResult.h"
#include "model/ModifyVServerGroupBackendServersRequest.h"
#include "model/ModifyVServerGroupBackendServersResult.h"
#include "model/DescribeSlbQuotasRequest.h"
#include "model/DescribeSlbQuotasResult.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeResult.h"
#include "model/DeleteRulesRequest.h"
@@ -102,6 +112,8 @@
#include "model/CreateMasterSlaveVServerGroupResult.h"
#include "model/SetBackendServersRequest.h"
#include "model/SetBackendServersResult.h"
#include "model/DeleteAccessControlListRequest.h"
#include "model/DeleteAccessControlListResult.h"
#include "model/RemoveVServerGroupBackendServersRequest.h"
#include "model/RemoveVServerGroupBackendServersResult.h"
#include "model/DescribeLoadBalancerAttributeRequest.h"
@@ -112,8 +124,16 @@
#include "model/SetServerCertificateNameResult.h"
#include "model/DeleteCACertificateRequest.h"
#include "model/DeleteCACertificateResult.h"
#include "model/SetAccessControlListAttributeRequest.h"
#include "model/SetAccessControlListAttributeResult.h"
#include "model/CreateLoadBalancerTCPListenerRequest.h"
#include "model/CreateLoadBalancerTCPListenerResult.h"
#include "model/DescribeAccessControlListAttributeRequest.h"
#include "model/DescribeAccessControlListAttributeResult.h"
#include "model/DescribeAccessControlListsRequest.h"
#include "model/DescribeAccessControlListsResult.h"
#include "model/DeleteDomainExtensionRequest.h"
#include "model/DeleteDomainExtensionResult.h"
#include "model/SetRuleRequest.h"
#include "model/SetRuleResult.h"
#include "model/DescribeMasterSlaveServerGroupsRequest.h"
@@ -132,6 +152,10 @@
#include "model/DescribeServerCertificatesResult.h"
#include "model/DescribeRulesRequest.h"
#include "model/DescribeRulesResult.h"
#include "model/RemoveAccessControlListEntryRequest.h"
#include "model/RemoveAccessControlListEntryResult.h"
#include "model/CreateDomainExtensionRequest.h"
#include "model/CreateDomainExtensionResult.h"
#include "model/DescribeRuleAttributeRequest.h"
#include "model/DescribeRuleAttributeResult.h"
#include "model/UploadServerCertificateRequest.h"
@@ -146,6 +170,8 @@
#include "model/SetVServerGroupAttributeResult.h"
#include "model/ModifyLoadBalancerInternetSpecRequest.h"
#include "model/ModifyLoadBalancerInternetSpecResult.h"
#include "model/CreateAccessControlListRequest.h"
#include "model/CreateAccessControlListResult.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/DescribeMasterSlaveServerGroupAttributeRequest.h"
@@ -171,6 +197,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT SlbClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::SetDomainExtensionAttributeResult> SetDomainExtensionAttributeOutcome;
typedef std::future<SetDomainExtensionAttributeOutcome> SetDomainExtensionAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetDomainExtensionAttributeRequest&, const SetDomainExtensionAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDomainExtensionAttributeAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerUDPListenerResult> CreateLoadBalancerUDPListenerOutcome;
typedef std::future<CreateLoadBalancerUDPListenerOutcome> CreateLoadBalancerUDPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerUDPListenerRequest&, const CreateLoadBalancerUDPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerUDPListenerAsyncHandler;
@@ -219,6 +248,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetLoadBalancerHTTPListenerAttributeResult> SetLoadBalancerHTTPListenerAttributeOutcome;
typedef std::future<SetLoadBalancerHTTPListenerAttributeOutcome> SetLoadBalancerHTTPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPListenerAttributeRequest&, const SetLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeDomainExtensionsResult> DescribeDomainExtensionsOutcome;
typedef std::future<DescribeDomainExtensionsOutcome> DescribeDomainExtensionsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeDomainExtensionsRequest&, const DescribeDomainExtensionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDomainExtensionsAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerAutoReleaseTimeResult> SetLoadBalancerAutoReleaseTimeOutcome;
typedef std::future<SetLoadBalancerAutoReleaseTimeOutcome> SetLoadBalancerAutoReleaseTimeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerAutoReleaseTimeRequest&, const SetLoadBalancerAutoReleaseTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerAutoReleaseTimeAsyncHandler;
@@ -234,6 +266,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetLoadBalancerHTTPSListenerAttributeResult> SetLoadBalancerHTTPSListenerAttributeOutcome;
typedef std::future<SetLoadBalancerHTTPSListenerAttributeOutcome> SetLoadBalancerHTTPSListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPSListenerAttributeRequest&, const SetLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPSListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::SetAutoRenewStatusResult> SetAutoRenewStatusOutcome;
typedef std::future<SetAutoRenewStatusOutcome> SetAutoRenewStatusOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetAutoRenewStatusRequest&, const SetAutoRenewStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAutoRenewStatusAsyncHandler;
typedef Outcome<Error, Model::DeleteLoadBalancerListenerResult> DeleteLoadBalancerListenerOutcome;
typedef std::future<DeleteLoadBalancerListenerOutcome> DeleteLoadBalancerListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerListenerRequest&, const DeleteLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerListenerAsyncHandler;
@@ -270,9 +305,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RemoveBackendServersResult> RemoveBackendServersOutcome;
typedef std::future<RemoveBackendServersOutcome> RemoveBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveBackendServersRequest&, const RemoveBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveBackendServersAsyncHandler;
typedef Outcome<Error, Model::AddAccessControlListEntryResult> AddAccessControlListEntryOutcome;
typedef std::future<AddAccessControlListEntryOutcome> AddAccessControlListEntryOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddAccessControlListEntryRequest&, const AddAccessControlListEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddAccessControlListEntryAsyncHandler;
typedef Outcome<Error, Model::ModifyVServerGroupBackendServersResult> ModifyVServerGroupBackendServersOutcome;
typedef std::future<ModifyVServerGroupBackendServersOutcome> ModifyVServerGroupBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyVServerGroupBackendServersRequest&, const ModifyVServerGroupBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyVServerGroupBackendServersAsyncHandler;
typedef Outcome<Error, Model::DescribeSlbQuotasResult> DescribeSlbQuotasOutcome;
typedef std::future<DescribeSlbQuotasOutcome> DescribeSlbQuotasOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeSlbQuotasRequest&, const DescribeSlbQuotasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlbQuotasAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerUDPListenerAttributeResult> DescribeLoadBalancerUDPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerUDPListenerAttributeOutcome> DescribeLoadBalancerUDPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerUDPListenerAttributeRequest&, const DescribeLoadBalancerUDPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerUDPListenerAttributeAsyncHandler;
@@ -291,6 +332,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetBackendServersResult> SetBackendServersOutcome;
typedef std::future<SetBackendServersOutcome> SetBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetBackendServersRequest&, const SetBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetBackendServersAsyncHandler;
typedef Outcome<Error, Model::DeleteAccessControlListResult> DeleteAccessControlListOutcome;
typedef std::future<DeleteAccessControlListOutcome> DeleteAccessControlListOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteAccessControlListRequest&, const DeleteAccessControlListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccessControlListAsyncHandler;
typedef Outcome<Error, Model::RemoveVServerGroupBackendServersResult> RemoveVServerGroupBackendServersOutcome;
typedef std::future<RemoveVServerGroupBackendServersOutcome> RemoveVServerGroupBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveVServerGroupBackendServersRequest&, const RemoveVServerGroupBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveVServerGroupBackendServersAsyncHandler;
@@ -306,9 +350,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteCACertificateResult> DeleteCACertificateOutcome;
typedef std::future<DeleteCACertificateOutcome> DeleteCACertificateOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteCACertificateRequest&, const DeleteCACertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCACertificateAsyncHandler;
typedef Outcome<Error, Model::SetAccessControlListAttributeResult> SetAccessControlListAttributeOutcome;
typedef std::future<SetAccessControlListAttributeOutcome> SetAccessControlListAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetAccessControlListAttributeRequest&, const SetAccessControlListAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAccessControlListAttributeAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerTCPListenerResult> CreateLoadBalancerTCPListenerOutcome;
typedef std::future<CreateLoadBalancerTCPListenerOutcome> CreateLoadBalancerTCPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerTCPListenerRequest&, const CreateLoadBalancerTCPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerTCPListenerAsyncHandler;
typedef Outcome<Error, Model::DescribeAccessControlListAttributeResult> DescribeAccessControlListAttributeOutcome;
typedef std::future<DescribeAccessControlListAttributeOutcome> DescribeAccessControlListAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeAccessControlListAttributeRequest&, const DescribeAccessControlListAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccessControlListAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeAccessControlListsResult> DescribeAccessControlListsOutcome;
typedef std::future<DescribeAccessControlListsOutcome> DescribeAccessControlListsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeAccessControlListsRequest&, const DescribeAccessControlListsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccessControlListsAsyncHandler;
typedef Outcome<Error, Model::DeleteDomainExtensionResult> DeleteDomainExtensionOutcome;
typedef std::future<DeleteDomainExtensionOutcome> DeleteDomainExtensionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteDomainExtensionRequest&, const DeleteDomainExtensionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDomainExtensionAsyncHandler;
typedef Outcome<Error, Model::SetRuleResult> SetRuleOutcome;
typedef std::future<SetRuleOutcome> SetRuleOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetRuleRequest&, const SetRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetRuleAsyncHandler;
@@ -336,6 +392,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeRulesResult> DescribeRulesOutcome;
typedef std::future<DescribeRulesOutcome> DescribeRulesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRulesRequest&, const DescribeRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRulesAsyncHandler;
typedef Outcome<Error, Model::RemoveAccessControlListEntryResult> RemoveAccessControlListEntryOutcome;
typedef std::future<RemoveAccessControlListEntryOutcome> RemoveAccessControlListEntryOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveAccessControlListEntryRequest&, const RemoveAccessControlListEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveAccessControlListEntryAsyncHandler;
typedef Outcome<Error, Model::CreateDomainExtensionResult> CreateDomainExtensionOutcome;
typedef std::future<CreateDomainExtensionOutcome> CreateDomainExtensionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateDomainExtensionRequest&, const CreateDomainExtensionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDomainExtensionAsyncHandler;
typedef Outcome<Error, Model::DescribeRuleAttributeResult> DescribeRuleAttributeOutcome;
typedef std::future<DescribeRuleAttributeOutcome> DescribeRuleAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRuleAttributeRequest&, const DescribeRuleAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRuleAttributeAsyncHandler;
@@ -357,6 +419,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ModifyLoadBalancerInternetSpecResult> ModifyLoadBalancerInternetSpecOutcome;
typedef std::future<ModifyLoadBalancerInternetSpecOutcome> ModifyLoadBalancerInternetSpecOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyLoadBalancerInternetSpecRequest&, const ModifyLoadBalancerInternetSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLoadBalancerInternetSpecAsyncHandler;
typedef Outcome<Error, Model::CreateAccessControlListResult> CreateAccessControlListOutcome;
typedef std::future<CreateAccessControlListOutcome> CreateAccessControlListOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateAccessControlListRequest&, const CreateAccessControlListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccessControlListAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerHTTPSListenerAttributeResult> DescribeLoadBalancerHTTPSListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerHTTPSListenerAttributeOutcome> DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest&, const DescribeLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler;
@@ -386,6 +451,9 @@ namespace AlibabaCloud
SlbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
SlbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~SlbClient();
SetDomainExtensionAttributeOutcome setDomainExtensionAttribute(const Model::SetDomainExtensionAttributeRequest &request)const;
void setDomainExtensionAttributeAsync(const Model::SetDomainExtensionAttributeRequest& request, const SetDomainExtensionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetDomainExtensionAttributeOutcomeCallable setDomainExtensionAttributeCallable(const Model::SetDomainExtensionAttributeRequest& request) const;
CreateLoadBalancerUDPListenerOutcome createLoadBalancerUDPListener(const Model::CreateLoadBalancerUDPListenerRequest &request)const;
void createLoadBalancerUDPListenerAsync(const Model::CreateLoadBalancerUDPListenerRequest& request, const CreateLoadBalancerUDPListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerUDPListenerOutcomeCallable createLoadBalancerUDPListenerCallable(const Model::CreateLoadBalancerUDPListenerRequest& request) const;
@@ -434,6 +502,9 @@ namespace AlibabaCloud
SetLoadBalancerHTTPListenerAttributeOutcome setLoadBalancerHTTPListenerAttribute(const Model::SetLoadBalancerHTTPListenerAttributeRequest &request)const;
void setLoadBalancerHTTPListenerAttributeAsync(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request, const SetLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerHTTPListenerAttributeOutcomeCallable setLoadBalancerHTTPListenerAttributeCallable(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request) const;
DescribeDomainExtensionsOutcome describeDomainExtensions(const Model::DescribeDomainExtensionsRequest &request)const;
void describeDomainExtensionsAsync(const Model::DescribeDomainExtensionsRequest& request, const DescribeDomainExtensionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDomainExtensionsOutcomeCallable describeDomainExtensionsCallable(const Model::DescribeDomainExtensionsRequest& request) const;
SetLoadBalancerAutoReleaseTimeOutcome setLoadBalancerAutoReleaseTime(const Model::SetLoadBalancerAutoReleaseTimeRequest &request)const;
void setLoadBalancerAutoReleaseTimeAsync(const Model::SetLoadBalancerAutoReleaseTimeRequest& request, const SetLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerAutoReleaseTimeOutcomeCallable setLoadBalancerAutoReleaseTimeCallable(const Model::SetLoadBalancerAutoReleaseTimeRequest& request) const;
@@ -449,6 +520,9 @@ namespace AlibabaCloud
SetLoadBalancerHTTPSListenerAttributeOutcome setLoadBalancerHTTPSListenerAttribute(const Model::SetLoadBalancerHTTPSListenerAttributeRequest &request)const;
void setLoadBalancerHTTPSListenerAttributeAsync(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request, const SetLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerHTTPSListenerAttributeOutcomeCallable setLoadBalancerHTTPSListenerAttributeCallable(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request) const;
SetAutoRenewStatusOutcome setAutoRenewStatus(const Model::SetAutoRenewStatusRequest &request)const;
void setAutoRenewStatusAsync(const Model::SetAutoRenewStatusRequest& request, const SetAutoRenewStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetAutoRenewStatusOutcomeCallable setAutoRenewStatusCallable(const Model::SetAutoRenewStatusRequest& request) const;
DeleteLoadBalancerListenerOutcome deleteLoadBalancerListener(const Model::DeleteLoadBalancerListenerRequest &request)const;
void deleteLoadBalancerListenerAsync(const Model::DeleteLoadBalancerListenerRequest& request, const DeleteLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLoadBalancerListenerOutcomeCallable deleteLoadBalancerListenerCallable(const Model::DeleteLoadBalancerListenerRequest& request) const;
@@ -485,9 +559,15 @@ namespace AlibabaCloud
RemoveBackendServersOutcome removeBackendServers(const Model::RemoveBackendServersRequest &request)const;
void removeBackendServersAsync(const Model::RemoveBackendServersRequest& request, const RemoveBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveBackendServersOutcomeCallable removeBackendServersCallable(const Model::RemoveBackendServersRequest& request) const;
AddAccessControlListEntryOutcome addAccessControlListEntry(const Model::AddAccessControlListEntryRequest &request)const;
void addAccessControlListEntryAsync(const Model::AddAccessControlListEntryRequest& request, const AddAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddAccessControlListEntryOutcomeCallable addAccessControlListEntryCallable(const Model::AddAccessControlListEntryRequest& request) const;
ModifyVServerGroupBackendServersOutcome modifyVServerGroupBackendServers(const Model::ModifyVServerGroupBackendServersRequest &request)const;
void modifyVServerGroupBackendServersAsync(const Model::ModifyVServerGroupBackendServersRequest& request, const ModifyVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyVServerGroupBackendServersOutcomeCallable modifyVServerGroupBackendServersCallable(const Model::ModifyVServerGroupBackendServersRequest& request) const;
DescribeSlbQuotasOutcome describeSlbQuotas(const Model::DescribeSlbQuotasRequest &request)const;
void describeSlbQuotasAsync(const Model::DescribeSlbQuotasRequest& request, const DescribeSlbQuotasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSlbQuotasOutcomeCallable describeSlbQuotasCallable(const Model::DescribeSlbQuotasRequest& request) const;
DescribeLoadBalancerUDPListenerAttributeOutcome describeLoadBalancerUDPListenerAttribute(const Model::DescribeLoadBalancerUDPListenerAttributeRequest &request)const;
void describeLoadBalancerUDPListenerAttributeAsync(const Model::DescribeLoadBalancerUDPListenerAttributeRequest& request, const DescribeLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerUDPListenerAttributeOutcomeCallable describeLoadBalancerUDPListenerAttributeCallable(const Model::DescribeLoadBalancerUDPListenerAttributeRequest& request) const;
@@ -506,6 +586,9 @@ namespace AlibabaCloud
SetBackendServersOutcome setBackendServers(const Model::SetBackendServersRequest &request)const;
void setBackendServersAsync(const Model::SetBackendServersRequest& request, const SetBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetBackendServersOutcomeCallable setBackendServersCallable(const Model::SetBackendServersRequest& request) const;
DeleteAccessControlListOutcome deleteAccessControlList(const Model::DeleteAccessControlListRequest &request)const;
void deleteAccessControlListAsync(const Model::DeleteAccessControlListRequest& request, const DeleteAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAccessControlListOutcomeCallable deleteAccessControlListCallable(const Model::DeleteAccessControlListRequest& request) const;
RemoveVServerGroupBackendServersOutcome removeVServerGroupBackendServers(const Model::RemoveVServerGroupBackendServersRequest &request)const;
void removeVServerGroupBackendServersAsync(const Model::RemoveVServerGroupBackendServersRequest& request, const RemoveVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveVServerGroupBackendServersOutcomeCallable removeVServerGroupBackendServersCallable(const Model::RemoveVServerGroupBackendServersRequest& request) const;
@@ -521,9 +604,21 @@ namespace AlibabaCloud
DeleteCACertificateOutcome deleteCACertificate(const Model::DeleteCACertificateRequest &request)const;
void deleteCACertificateAsync(const Model::DeleteCACertificateRequest& request, const DeleteCACertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCACertificateOutcomeCallable deleteCACertificateCallable(const Model::DeleteCACertificateRequest& request) const;
SetAccessControlListAttributeOutcome setAccessControlListAttribute(const Model::SetAccessControlListAttributeRequest &request)const;
void setAccessControlListAttributeAsync(const Model::SetAccessControlListAttributeRequest& request, const SetAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetAccessControlListAttributeOutcomeCallable setAccessControlListAttributeCallable(const Model::SetAccessControlListAttributeRequest& request) const;
CreateLoadBalancerTCPListenerOutcome createLoadBalancerTCPListener(const Model::CreateLoadBalancerTCPListenerRequest &request)const;
void createLoadBalancerTCPListenerAsync(const Model::CreateLoadBalancerTCPListenerRequest& request, const CreateLoadBalancerTCPListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerTCPListenerOutcomeCallable createLoadBalancerTCPListenerCallable(const Model::CreateLoadBalancerTCPListenerRequest& request) const;
DescribeAccessControlListAttributeOutcome describeAccessControlListAttribute(const Model::DescribeAccessControlListAttributeRequest &request)const;
void describeAccessControlListAttributeAsync(const Model::DescribeAccessControlListAttributeRequest& request, const DescribeAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccessControlListAttributeOutcomeCallable describeAccessControlListAttributeCallable(const Model::DescribeAccessControlListAttributeRequest& request) const;
DescribeAccessControlListsOutcome describeAccessControlLists(const Model::DescribeAccessControlListsRequest &request)const;
void describeAccessControlListsAsync(const Model::DescribeAccessControlListsRequest& request, const DescribeAccessControlListsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccessControlListsOutcomeCallable describeAccessControlListsCallable(const Model::DescribeAccessControlListsRequest& request) const;
DeleteDomainExtensionOutcome deleteDomainExtension(const Model::DeleteDomainExtensionRequest &request)const;
void deleteDomainExtensionAsync(const Model::DeleteDomainExtensionRequest& request, const DeleteDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDomainExtensionOutcomeCallable deleteDomainExtensionCallable(const Model::DeleteDomainExtensionRequest& request) const;
SetRuleOutcome setRule(const Model::SetRuleRequest &request)const;
void setRuleAsync(const Model::SetRuleRequest& request, const SetRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetRuleOutcomeCallable setRuleCallable(const Model::SetRuleRequest& request) const;
@@ -551,6 +646,12 @@ namespace AlibabaCloud
DescribeRulesOutcome describeRules(const Model::DescribeRulesRequest &request)const;
void describeRulesAsync(const Model::DescribeRulesRequest& request, const DescribeRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRulesOutcomeCallable describeRulesCallable(const Model::DescribeRulesRequest& request) const;
RemoveAccessControlListEntryOutcome removeAccessControlListEntry(const Model::RemoveAccessControlListEntryRequest &request)const;
void removeAccessControlListEntryAsync(const Model::RemoveAccessControlListEntryRequest& request, const RemoveAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveAccessControlListEntryOutcomeCallable removeAccessControlListEntryCallable(const Model::RemoveAccessControlListEntryRequest& request) const;
CreateDomainExtensionOutcome createDomainExtension(const Model::CreateDomainExtensionRequest &request)const;
void createDomainExtensionAsync(const Model::CreateDomainExtensionRequest& request, const CreateDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDomainExtensionOutcomeCallable createDomainExtensionCallable(const Model::CreateDomainExtensionRequest& request) const;
DescribeRuleAttributeOutcome describeRuleAttribute(const Model::DescribeRuleAttributeRequest &request)const;
void describeRuleAttributeAsync(const Model::DescribeRuleAttributeRequest& request, const DescribeRuleAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRuleAttributeOutcomeCallable describeRuleAttributeCallable(const Model::DescribeRuleAttributeRequest& request) const;
@@ -572,6 +673,9 @@ namespace AlibabaCloud
ModifyLoadBalancerInternetSpecOutcome modifyLoadBalancerInternetSpec(const Model::ModifyLoadBalancerInternetSpecRequest &request)const;
void modifyLoadBalancerInternetSpecAsync(const Model::ModifyLoadBalancerInternetSpecRequest& request, const ModifyLoadBalancerInternetSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLoadBalancerInternetSpecOutcomeCallable modifyLoadBalancerInternetSpecCallable(const Model::ModifyLoadBalancerInternetSpecRequest& request) const;
CreateAccessControlListOutcome createAccessControlList(const Model::CreateAccessControlListRequest &request)const;
void createAccessControlListAsync(const Model::CreateAccessControlListRequest& request, const CreateAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAccessControlListOutcomeCallable createAccessControlListCallable(const Model::CreateAccessControlListRequest& request) const;
DescribeLoadBalancerHTTPSListenerAttributeOutcome describeLoadBalancerHTTPSListenerAttribute(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest &request)const;
void describeLoadBalancerHTTPSListenerAttributeAsync(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request, const DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable describeLoadBalancerHTTPSListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request) const;

75
slb/include/alibabacloud/slb/model/AddAccessControlListEntryRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddAccessControlListEntryRequest : public RpcServiceRequest
{
public:
AddAccessControlListEntryRequest();
~AddAccessControlListEntryRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getAclId()const;
void setAclId(const std::string& aclId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getAclEntrys()const;
void setAclEntrys(const std::string& aclEntrys);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string aclId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string aclEntrys_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYREQUEST_H_

49
slb/include/alibabacloud/slb/model/AddAccessControlListEntryResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddAccessControlListEntryResult : public ServiceResult
{
public:
AddAccessControlListEntryResult();
explicit AddAccessControlListEntryResult(const std::string &payload);
~AddAccessControlListEntryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYRESULT_H_

22
slb/include/alibabacloud/slb/model/AddBackendServersResult.h
View File

@@ -32,24 +32,28 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT AddBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
std::string weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
std::string serverIp;
std::string weight;
};
AddBackendServersResult();
explicit AddBackendServersResult(const std::string &payload);
~AddBackendServersResult();
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
};
}

24
slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h
View File

@@ -32,25 +32,29 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT AddVServerGroupBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
AddVServerGroupBackendServersResult();
explicit AddVServerGroupBackendServersResult(const std::string &payload);
~AddVServerGroupBackendServersResult();
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}

75
slb/include/alibabacloud/slb/model/CreateAccessControlListRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateAccessControlListRequest : public RpcServiceRequest
{
public:
CreateAccessControlListRequest();
~CreateAccessControlListRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAclName()const;
void setAclName(const std::string& aclName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAddressIPVersion()const;
void setAddressIPVersion(const std::string& addressIPVersion);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string aclName_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string addressIPVersion_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTREQUEST_H_

51
slb/include/alibabacloud/slb/model/CreateAccessControlListResult.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_SLB_MODEL_CREATEACCESSCONTROLLISTRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateAccessControlListResult : public ServiceResult
{
public:
CreateAccessControlListResult();
explicit CreateAccessControlListResult(const std::string &payload);
~CreateAccessControlListResult();
std::string getAclId()const;
protected:
void parse(const std::string &payload);
private:
std::string aclId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTRESULT_H_

78
slb/include/alibabacloud/slb/model/CreateDomainExtensionRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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_SLB_MODEL_CREATEDOMAINEXTENSIONREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateDomainExtensionRequest : public RpcServiceRequest
{
public:
CreateDomainExtensionRequest();
~CreateDomainExtensionRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getDomain()const;
void setDomain(const std::string& domain);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
void setServerCertificateId(const std::string& serverCertificateId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string domain_;
long ownerId_;
std::string serverCertificateId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONREQUEST_H_

53
slb/include/alibabacloud/slb/model/CreateDomainExtensionResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateDomainExtensionResult : public ServiceResult
{
public:
CreateDomainExtensionResult();
explicit CreateDomainExtensionResult(const std::string &payload);
~CreateDomainExtensionResult();
int getListenerPort()const;
std::string getDomainExtensionId()const;
protected:
void parse(const std::string &payload);
private:
int listenerPort_;
std::string domainExtensionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONRESULT_H_

27
slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h
View File

@@ -41,18 +41,28 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getListenerForward()const;
void setListenerForward(const std::string& listenerForward);
std::string getXForwardedFor()const;
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getForwardPort()const;
void setForwardPort(int forwardPort);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getRegionId()const;
@@ -61,8 +71,12 @@ namespace AlibabaCloud
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getCookie()const;
@@ -75,6 +89,8 @@ namespace AlibabaCloud
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
int getRequestTimeout()const;
void setRequestTimeout(int requestTimeout);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getGzip()const;
@@ -83,6 +99,8 @@ namespace AlibabaCloud
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
int getIdleTimeout()const;
void setIdleTimeout(int idleTimeout);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getXForwardedFor_SLBIP()const;
@@ -104,27 +122,36 @@ namespace AlibabaCloud
std::string access_key_id_;
long resourceOwnerId_;
int healthCheckTimeout_;
std::string listenerForward_;
std::string xForwardedFor_;
std::string healthCheckURI_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
std::string healthCheck_;
int forwardPort_;
int maxConnection_;
std::string regionId_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string cookie_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string healthCheckDomain_;
int requestTimeout_;
std::string ownerAccount_;
std::string gzip_;
long ownerId_;
std::string tags_;
int idleTimeout_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int backendServerPort_;

27
slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h
View File

@@ -45,24 +45,36 @@ namespace AlibabaCloud
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getEnableHttp2()const;
void setEnableHttp2(const std::string& enableHttp2);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getCookie()const;
@@ -75,10 +87,14 @@ namespace AlibabaCloud
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
int getRequestTimeout()const;
void setRequestTimeout(int requestTimeout);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getGzip()const;
void setGzip(const std::string& gzip);
std::string getTLSCipherPolicy()const;
void setTLSCipherPolicy(const std::string& tLSCipherPolicy);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
@@ -87,6 +103,8 @@ namespace AlibabaCloud
void setCACertificateId(const std::string& cACertificateId);
std::string getTags()const;
void setTags(const std::string& tags);
int getIdleTimeout()const;
void setIdleTimeout(int idleTimeout);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getXForwardedFor_SLBIP()const;
@@ -110,27 +128,36 @@ namespace AlibabaCloud
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
std::string healthCheck_;
int maxConnection_;
std::string enableHttp2_;
std::string regionId_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string cookie_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string healthCheckDomain_;
int requestTimeout_;
std::string ownerAccount_;
std::string gzip_;
std::string tLSCipherPolicy_;
long ownerId_;
std::string serverCertificateId_;
std::string cACertificateId_;
std::string tags_;
int idleTimeout_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int backendServerPort_;

69
slb/include/alibabacloud/slb/model/CreateLoadBalancerRequest.h
View File

@@ -37,46 +37,48 @@ namespace AlibabaCloud
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getLoadBalancerSpec()const;
void setLoadBalancerSpec(const std::string& loadBalancerSpec);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAddressIPVersion()const;
void setAddressIPVersion(const std::string& addressIPVersion);
std::string getMasterZoneId()const;
void setMasterZoneId(const std::string& masterZoneId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
int getDuration()const;
void setDuration(int duration);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getEnableVpcVipFlow()const;
void setEnableVpcVipFlow(const std::string& enableVpcVipFlow);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getSlaveZoneId()const;
void setSlaveZoneId(const std::string& slaveZoneId);
std::string getLoadBalancerSpec()const;
void setLoadBalancerSpec(const std::string& loadBalancerSpec);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getEnableVpcVipFlow()const;
void setEnableVpcVipFlow(const std::string& enableVpcVipFlow);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getPricingCycle()const;
@@ -84,26 +86,27 @@ namespace AlibabaCloud
private:
std::string access_key_id_;
std::string loadBalancerSpec_;
long resourceOwnerId_;
bool autoPay_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string clientToken_;
std::string ownerAccount_;
long ownerId_;
std::string addressIPVersion_;
std::string masterZoneId_;
std::string tags_;
std::string vSwitchId_;
int duration_;
std::string resourceGroupId_;
std::string loadBalancerName_;
std::string enableVpcVipFlow_;
std::string regionId_;
std::string internetChargeType_;
std::string vpcId_;
std::string addressType_;
std::string slaveZoneId_;
std::string loadBalancerSpec_;
bool autoPay_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string vSwitchId_;
std::string enableVpcVipFlow_;
std::string internetChargeType_;
std::string vpcId_;
std::string payType_;
std::string pricingCycle_;

34
slb/include/alibabacloud/slb/model/CreateLoadBalancerResult.h
View File

@@ -37,26 +37,28 @@ namespace AlibabaCloud
CreateLoadBalancerResult();
explicit CreateLoadBalancerResult(const std::string &payload);
~CreateLoadBalancerResult();
std::string getLoadBalancerName()const;
std::string getResourceGroupId()const;
std::string getAddress()const;
std::string getVpcId()const;
std::string getNetworkType()const;
std::string getVSwitchId()const;
std::string getLoadBalancerId()const;
long getOrderId()const;
std::string getLoadBalancerName()const;
std::string getResourceGroupId()const;
std::string getAddress()const;
std::string getVpcId()const;
std::string getNetworkType()const;
std::string getVSwitchId()const;
std::string getAddressIPVersion()const;
std::string getLoadBalancerId()const;
long getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerName_;
std::string resourceGroupId_;
std::string address_;
std::string vpcId_;
std::string networkType_;
std::string vSwitchId_;
std::string loadBalancerId_;
long orderId_;
std::string loadBalancerName_;
std::string resourceGroupId_;
std::string address_;
std::string vpcId_;
std::string networkType_;
std::string vSwitchId_;
std::string addressIPVersion_;
std::string loadBalancerId_;
long orderId_;
};
}

15
slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h
View File

@@ -43,12 +43,18 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
int getEstablishedTimeout()const;
void setEstablishedTimeout(int establishedTimeout);
int getMaxConnection()const;
@@ -57,8 +63,12 @@ namespace AlibabaCloud
void setRegionId(const std::string& regionId);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getHealthCheckType()const;
@@ -93,14 +103,19 @@ namespace AlibabaCloud
int healthCheckConnectTimeout_;
long resourceOwnerId_;
std::string healthCheckURI_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
int establishedTimeout_;
int maxConnection_;
std::string regionId_;
int persistenceTimeout_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;

57
slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h
View File

@@ -37,12 +37,34 @@ namespace AlibabaCloud
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getHealthCheckConnectTimeout()const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount()const;
@@ -51,32 +73,20 @@ namespace AlibabaCloud
void setBandwidth(int bandwidth);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::string getHealthCheckReq()const;
void setHealthCheckReq(const std::string& healthCheckReq);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getHealthCheckExp()const;
void setHealthCheckExp(const std::string& healthCheckExp);
int getHealthCheckConnectPort()const;
@@ -84,26 +94,31 @@ namespace AlibabaCloud
private:
std::string access_key_id_;
std::string vServerGroupId_;
int healthCheckConnectTimeout_;
long resourceOwnerId_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
int maxConnection_;
std::string regionId_;
int persistenceTimeout_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
int unhealthyThreshold_;
long ownerId_;
int healthyThreshold_;
std::string tags_;
std::string scheduler_;
std::string loadBalancerId_;
int maxConnection_;
std::string masterSlaveServerGroupId_;
std::string healthCheckReq_;
std::string regionId_;
int backendServerPort_;
int healthCheckInterval_;
int persistenceTimeout_;
std::string healthCheckExp_;
int healthCheckConnectPort_;

26
slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h
View File

@@ -32,26 +32,30 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveServerGroupResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverType;
std::string serverId;
int port;
int weight;
};
struct MasterSlaveBackendServer
{
std::string serverType;
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
CreateMasterSlaveServerGroupResult();
explicit CreateMasterSlaveServerGroupResult(const std::string &payload);
~CreateMasterSlaveServerGroupResult();
std::string getMasterSlaveServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
std::string getMasterSlaveServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}

26
slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h
View File

@@ -32,26 +32,30 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverId;
int port;
int isBackup;
int weight;
};
struct MasterSlaveBackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int isBackup;
int weight;
};
CreateMasterSlaveVServerGroupResult();
explicit CreateMasterSlaveVServerGroupResult(const std::string &payload);
~CreateMasterSlaveVServerGroupResult();
std::string getMasterSlaveVServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
std::string getMasterSlaveVServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}

14
slb/include/alibabacloud/slb/model/CreateRulesResult.h
View File

@@ -32,22 +32,22 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT CreateRulesResult : public ServiceResult
{
public:
struct Rule
{
std::string ruleId;
std::string ruleName;
};
struct Rule
{
std::string ruleId;
std::string ruleName;
};
CreateRulesResult();
explicit CreateRulesResult(const std::string &payload);
~CreateRulesResult();
std::vector<Rule> getRules()const;
std::vector<Rule> getRules()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Rule> rules_;
std::vector<Rule> rules_;
};
}

24
slb/include/alibabacloud/slb/model/CreateVServerGroupResult.h
View File

@@ -32,25 +32,29 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT CreateVServerGroupResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
CreateVServerGroupResult();
explicit CreateVServerGroupResult(const std::string &payload);
~CreateVServerGroupResult();
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}

72
slb/include/alibabacloud/slb/model/DeleteAccessControlListRequest.h 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.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteAccessControlListRequest : public RpcServiceRequest
{
public:
DeleteAccessControlListRequest();
~DeleteAccessControlListRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getAclId()const;
void setAclId(const std::string& aclId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string aclId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteAccessControlListResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteAccessControlListResult : public ServiceResult
{
public:
DeleteAccessControlListResult();
explicit DeleteAccessControlListResult(const std::string &payload);
~DeleteAccessControlListResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTRESULT_H_

69
slb/include/alibabacloud/slb/model/DeleteDomainExtensionRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteDomainExtensionRequest : public RpcServiceRequest
{
public:
DeleteDomainExtensionRequest();
~DeleteDomainExtensionRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getDomainExtensionId()const;
void setDomainExtensionId(const std::string& domainExtensionId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string domainExtensionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteDomainExtensionResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteDomainExtensionResult : public ServiceResult
{
public:
DeleteDomainExtensionResult();
explicit DeleteDomainExtensionResult(const std::string &payload);
~DeleteDomainExtensionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONRESULT_H_

75
slb/include/alibabacloud/slb/model/DescribeAccessControlListAttributeRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeAccessControlListAttributeRequest : public RpcServiceRequest
{
public:
DescribeAccessControlListAttributeRequest();
~DescribeAccessControlListAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getAclId()const;
void setAclId(const std::string& aclId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getAclEntryComment()const;
void setAclEntryComment(const std::string& aclEntryComment);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string aclId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string aclEntryComment_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTEREQUEST_H_

71
slb/include/alibabacloud/slb/model/DescribeAccessControlListAttributeResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeAccessControlListAttributeResult : public ServiceResult
{
public:
struct AclEntry
{
std::string aclEntryComment;
std::string aclEntryIP;
};
struct RelatedListener
{
int listenerPort;
std::string loadBalancerId;
std::string aclType;
std::string protocol;
};
DescribeAccessControlListAttributeResult();
explicit DescribeAccessControlListAttributeResult(const std::string &payload);
~DescribeAccessControlListAttributeResult();
std::vector<AclEntry> getAclEntrys()const;
std::string getAclId()const;
std::string getAddressIPVersion()const;
std::vector<RelatedListener> getRelatedListeners()const;
std::string getAclName()const;
protected:
void parse(const std::string &payload);
private:
std::vector<AclEntry> aclEntrys_;
std::string aclId_;
std::string addressIPVersion_;
std::vector<RelatedListener> relatedListeners_;
std::string aclName_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTERESULT_H_

81
slb/include/alibabacloud/slb/model/DescribeAccessControlListsRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeAccessControlListsRequest : public RpcServiceRequest
{
public:
DescribeAccessControlListsRequest();
~DescribeAccessControlListsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAclName()const;
void setAclName(const std::string& aclName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAddressIPVersion()const;
void setAddressIPVersion(const std::string& addressIPVersion);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string aclName_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string addressIPVersion_;
int pageNumber_;
std::string accessKeyId_;
std::string tags_;
std::string regionId_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeAccessControlListsResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeAccessControlListsResult : public ServiceResult
{
public:
struct Acl
{
std::string aclId;
std::string addressIPVersion;
std::string aclName;
};
DescribeAccessControlListsResult();
explicit DescribeAccessControlListsResult(const std::string &payload);
~DescribeAccessControlListsResult();
std::vector<Acl> getAcls()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Acl> acls_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSRESULT_H_

27
slb/include/alibabacloud/slb/model/DescribeCACertificatesResult.h
View File

@@ -32,27 +32,30 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeCACertificatesResult : public ServiceResult
{
public:
struct CACertificate
{
std::string fingerprint;
std::string resourceGroupId;
std::string cACertificateId;
std::string createTime;
std::string cACertificateName;
std::string regionId;
long createTimeStamp;
};
struct CACertificate
{
std::string fingerprint;
std::string resourceGroupId;
long expireTimeStamp;
std::string cACertificateId;
std::string createTime;
std::string cACertificateName;
std::string regionId;
std::string expireTime;
long createTimeStamp;
std::string commonName;
};
DescribeCACertificatesResult();
explicit DescribeCACertificatesResult(const std::string &payload);
~DescribeCACertificatesResult();
std::vector<CACertificate> getCACertificates()const;
std::vector<CACertificate> getCACertificates()const;
protected:
void parse(const std::string &payload);
private:
std::vector<CACertificate> cACertificates_;
std::vector<CACertificate> cACertificates_;
};
}

75
slb/include/alibabacloud/slb/model/DescribeDomainExtensionsRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeDomainExtensionsRequest : public RpcServiceRequest
{
public:
DescribeDomainExtensionsRequest();
~DescribeDomainExtensionsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getDomainExtensionId()const;
void setDomainExtensionId(const std::string& domainExtensionId);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string domainExtensionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeDomainExtensionsResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeDomainExtensionsResult : public ServiceResult
{
public:
struct DomainExtension
{
std::string domainExtensionId;
std::string serverCertificateId;
std::string domain;
};
DescribeDomainExtensionsResult();
explicit DescribeDomainExtensionsResult(const std::string &payload);
~DescribeDomainExtensionsResult();
std::vector<DomainExtension> getDomainExtensions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DomainExtension> domainExtensions_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSRESULT_H_

21
slb/include/alibabacloud/slb/model/DescribeHealthStatusResult.h
View File

@@ -32,24 +32,27 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeHealthStatusResult : public ServiceResult
{
public:
struct BackendServer
{
int listenerPort;
std::string serverId;
int port;
std::string serverHealthStatus;
};
struct BackendServer
{
int listenerPort;
std::string type;
std::string serverId;
std::string eniHost;
int port;
std::string serverIp;
std::string serverHealthStatus;
};
DescribeHealthStatusResult();
explicit DescribeHealthStatusResult(const std::string &payload);
~DescribeHealthStatusResult();
std::vector<BackendServer> getBackendServers()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::vector<BackendServer> backendServers_;
std::vector<BackendServer> backendServers_;
};
}

8
slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h
View File

@@ -37,14 +37,14 @@ namespace AlibabaCloud
DescribeListenerAccessControlAttributeResult();
explicit DescribeListenerAccessControlAttributeResult(const std::string &payload);
~DescribeListenerAccessControlAttributeResult();
std::string getAccessControlStatus()const;
std::string getSourceItems()const;
std::string getAccessControlStatus()const;
std::string getSourceItems()const;
protected:
void parse(const std::string &payload);
private:
std::string accessControlStatus_;
std::string sourceItems_;
std::string accessControlStatus_;
std::string sourceItems_;
};
}

150
slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h
View File

@@ -32,82 +32,98 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeResult : public ServiceResult
{
public:
struct ListenerPortAndProtocal
{
int listenerPort;
std::string listenerProtocal;
};
struct ListenerPortAndProtocol
{
int listenerPort;
std::string listenerProtocol;
};
struct BackendServer
{
std::string serverId;
int weight;
};
struct ListenerPortAndProtocal
{
int listenerPort;
std::string listenerProtocal;
};
struct ListenerPortAndProtocol
{
std::string listenerForward;
int listenerPort;
int forwardPort;
std::string listenerProtocol;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
std::string serverIp;
int weight;
};
DescribeLoadBalancerAttributeResult();
explicit DescribeLoadBalancerAttributeResult(const std::string &payload);
~DescribeLoadBalancerAttributeResult();
std::vector<ListenerPortAndProtocal> getListenerPortsAndProtocal()const;
std::string getResourceGroupId()const;
std::string getAddress()const;
std::string getEndTime()const;
std::vector<ListenerPortAndProtocol> getListenerPortsAndProtocol()const;
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getLoadBalancerSpec()const;
std::string getNetworkType()const;
int getBandwidth()const;
std::vector<std::string> getListenerPorts()const;
std::string getMasterZoneId()const;
std::string getVSwitchId()const;
std::string getCreateTime()const;
std::string getPayType()const;
std::string getSlaveZoneId()const;
std::string getInternetChargeType()const;
std::string getRegionIdAlias()const;
std::string getLoadBalancerName()const;
std::string getVpcId()const;
long getEndTimeStamp()const;
std::string getRegionId()const;
std::string getAddressType()const;
std::string getLoadBalancerStatus()const;
long getCreateTimeStamp()const;
long getAutoReleaseTime()const;
int getRenewalDuration()const;
std::vector<ListenerPortAndProtocal> getListenerPortsAndProtocal()const;
std::string getResourceGroupId()const;
std::string getAddress()const;
std::string getEndTime()const;
std::string getAddressIPVersion()const;
std::vector<ListenerPortAndProtocol> getListenerPortsAndProtocol()const;
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getLoadBalancerSpec()const;
std::string getNetworkType()const;
int getBandwidth()const;
std::vector<std::string> getListenerPorts()const;
std::string getMasterZoneId()const;
std::string getCloudType()const;
std::string getVSwitchId()const;
std::string getCreateTime()const;
std::string getRenewalStatus()const;
std::string getRenewalCycUnit()const;
std::string getPayType()const;
std::string getSlaveZoneId()const;
std::string getInternetChargeType()const;
std::string getRegionIdAlias()const;
std::string getLoadBalancerName()const;
std::string getVpcId()const;
long getEndTimeStamp()const;
std::string getRegionId()const;
std::string getAddressType()const;
std::string getLoadBalancerStatus()const;
long getCreateTimeStamp()const;
long getAutoReleaseTime()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ListenerPortAndProtocal> listenerPortsAndProtocal_;
std::string resourceGroupId_;
std::string address_;
std::string endTime_;
std::vector<ListenerPortAndProtocol> listenerPortsAndProtocol_;
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string loadBalancerSpec_;
std::string networkType_;
int bandwidth_;
std::vector<std::string> listenerPorts_;
std::string masterZoneId_;
std::string vSwitchId_;
std::string createTime_;
std::string payType_;
std::string slaveZoneId_;
std::string internetChargeType_;
std::string regionIdAlias_;
std::string loadBalancerName_;
std::string vpcId_;
long endTimeStamp_;
std::string regionId_;
std::string addressType_;
std::string loadBalancerStatus_;
long createTimeStamp_;
long autoReleaseTime_;
int renewalDuration_;
std::vector<ListenerPortAndProtocal> listenerPortsAndProtocal_;
std::string resourceGroupId_;
std::string address_;
std::string endTime_;
std::string addressIPVersion_;
std::vector<ListenerPortAndProtocol> listenerPortsAndProtocol_;
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string loadBalancerSpec_;
std::string networkType_;
int bandwidth_;
std::vector<std::string> listenerPorts_;
std::string masterZoneId_;
std::string cloudType_;
std::string vSwitchId_;
std::string createTime_;
std::string renewalStatus_;
std::string renewalCycUnit_;
std::string payType_;
std::string slaveZoneId_;
std::string internetChargeType_;
std::string regionIdAlias_;
std::string loadBalancerName_;
std::string vpcId_;
long endTimeStamp_;
std::string regionId_;
std::string addressType_;
std::string loadBalancerStatus_;
long createTimeStamp_;
long autoReleaseTime_;
};
}

4
slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeResult.h
View File

@@ -37,12 +37,12 @@ namespace AlibabaCloud
DescribeLoadBalancerAutoReleaseTimeResult();
explicit DescribeLoadBalancerAutoReleaseTimeResult(const std::string &payload);
~DescribeLoadBalancerAutoReleaseTimeResult();
long getAutoReleaseTime()const;
long getAutoReleaseTime()const;
protected:
void parse(const std::string &payload);
private:
long autoReleaseTime_;
long autoReleaseTime_;
};
}

132
slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h
View File

@@ -32,67 +32,95 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeResult : public ServiceResult
{
public:
struct Rule
{
std::string vServerGroupId;
std::string ruleId;
std::string domain;
std::string ruleName;
std::string url;
};
DescribeLoadBalancerHTTPListenerAttributeResult();
explicit DescribeLoadBalancerHTTPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerHTTPListenerAttributeResult();
int getCookieTimeout()const;
int getMaxConnection()const;
std::string getVServerGroupId()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getBackendServerPort()const;
std::string getXForwardedFor_SLBID()const;
int getHealthCheckConnectPort()const;
int getBandwidth()const;
std::string getSecurityStatus()const;
std::string getGzip()const;
std::string getStickySessionType()const;
std::string getXForwardedFor_SLBIP()const;
std::string getHealthCheckHttpCode()const;
std::string getStatus()const;
std::string getCookie()const;
int getListenerPort()const;
int getHealthCheckInterval()const;
int getHealthCheckTimeout()const;
std::string getStickySession()const;
int getHealthyThreshold()const;
std::string getXForwardedFor()const;
std::string getHealthCheckDomain()const;
std::string getXForwardedFor_proto()const;
int getCookieTimeout()const;
int getMaxConnection()const;
std::string getVServerGroupId()const;
std::string getDescription()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getIdleTimeout()const;
int getBackendServerPort()const;
std::string getXForwardedFor_SLBID()const;
int getHealthCheckConnectPort()const;
int getBandwidth()const;
std::string getSecurityStatus()const;
std::string getGzip()const;
std::string getStickySessionType()const;
std::string getXForwardedFor_SLBIP()const;
std::string getHealthCheckHttpCode()const;
std::string getStatus()const;
std::string getCookie()const;
int getListenerPort()const;
int getRequestTimeout()const;
int getHealthCheckInterval()const;
std::string getAclId()const;
int getHealthCheckTimeout()const;
std::vector<Rule> getRules()const;
std::string getListenerForward()const;
std::string getStickySession()const;
std::string getAclStatus()const;
int getForwardPort()const;
std::string getVpcIds()const;
int getHealthyThreshold()const;
std::string getXForwardedFor()const;
std::string getHealthCheckDomain()const;
std::string getXForwardedFor_proto()const;
std::string getAclType()const;
protected:
void parse(const std::string &payload);
private:
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int backendServerPort_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string stickySessionType_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int healthCheckInterval_;
int healthCheckTimeout_;
std::string stickySession_;
int healthyThreshold_;
std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string xForwardedFor_proto_;
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
std::string description_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int idleTimeout_;
int backendServerPort_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string stickySessionType_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int requestTimeout_;
int healthCheckInterval_;
std::string aclId_;
int healthCheckTimeout_;
std::vector<Rule> rules_;
std::string listenerForward_;
std::string stickySession_;
std::string aclStatus_;
int forwardPort_;
std::string vpcIds_;
int healthyThreshold_;
std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string xForwardedFor_proto_;
std::string aclType_;
};
}

148
slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h
View File

@@ -32,71 +32,107 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPSListenerAttributeResult : public ServiceResult
{
public:
struct Rule
{
std::string vServerGroupId;
std::string ruleId;
std::string domain;
std::string ruleName;
std::string url;
};
struct DomainExtension
{
std::string domainExtensionId;
std::string serverCertificateId;
std::string domain;
};
DescribeLoadBalancerHTTPSListenerAttributeResult();
explicit DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerHTTPSListenerAttributeResult();
int getCookieTimeout()const;
int getMaxConnection()const;
std::string getVServerGroupId()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getBackendServerPort()const;
std::string getXForwardedFor_SLBID()const;
int getHealthCheckConnectPort()const;
int getBandwidth()const;
std::string getSecurityStatus()const;
std::string getGzip()const;
std::string getServerCertificateId()const;
std::string getStickySessionType()const;
std::string getXForwardedFor_SLBIP()const;
std::string getHealthCheckHttpCode()const;
std::string getStatus()const;
std::string getCookie()const;
int getListenerPort()const;
int getHealthCheckInterval()const;
std::string getCACertificateId()const;
int getHealthCheckTimeout()const;
std::string getStickySession()const;
int getHealthyThreshold()const;
std::string getXForwardedFor()const;
std::string getHealthCheckDomain()const;
std::string getXForwardedFor_proto()const;
int getCookieTimeout()const;
int getMaxConnection()const;
std::string getVServerGroupId()const;
std::string getDescription()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::vector<DomainExtension> getDomainExtensions()const;
std::string getHealthCheck()const;
int getIdleTimeout()const;
int getBackendServerPort()const;
std::string getXForwardedFor_SLBID()const;
int getHealthCheckConnectPort()const;
int getBandwidth()const;
std::string getSecurityStatus()const;
std::string getGzip()const;
std::string getServerCertificateId()const;
std::string getStickySessionType()const;
std::string getXForwardedFor_SLBIP()const;
std::string getHealthCheckHttpCode()const;
std::string getStatus()const;
std::string getCookie()const;
int getListenerPort()const;
int getRequestTimeout()const;
int getHealthCheckInterval()const;
std::string getTLSCipherPolicy()const;
std::string getCACertificateId()const;
std::string getAclId()const;
int getHealthCheckTimeout()const;
std::vector<Rule> getRules()const;
std::string getStickySession()const;
std::string getAclStatus()const;
std::string getVpcIds()const;
int getHealthyThreshold()const;
std::string getXForwardedFor()const;
std::string getHealthCheckDomain()const;
std::string getXForwardedFor_proto()const;
std::string getAclType()const;
std::string getEnableHttp2()const;
protected:
void parse(const std::string &payload);
private:
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int backendServerPort_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string serverCertificateId_;
std::string stickySessionType_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int healthCheckInterval_;
std::string cACertificateId_;
int healthCheckTimeout_;
std::string stickySession_;
int healthyThreshold_;
std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string xForwardedFor_proto_;
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
std::string description_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::vector<DomainExtension> domainExtensions_;
std::string healthCheck_;
int idleTimeout_;
int backendServerPort_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string serverCertificateId_;
std::string stickySessionType_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int requestTimeout_;
int healthCheckInterval_;
std::string tLSCipherPolicy_;
std::string cACertificateId_;
std::string aclId_;
int healthCheckTimeout_;
std::vector<Rule> rules_;
std::string stickySession_;
std::string aclStatus_;
std::string vpcIds_;
int healthyThreshold_;
std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string xForwardedFor_proto_;
std::string aclType_;
std::string enableHttp2_;
};
}

94
slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h
View File

@@ -37,52 +37,62 @@ namespace AlibabaCloud
DescribeLoadBalancerTCPListenerAttributeResult();
explicit DescribeLoadBalancerTCPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerTCPListenerAttributeResult();
std::string getStatus()const;
int getMaxConnection()const;
int getListenerPort()const;
std::string getVServerGroupId()const;
std::string getSynProxy()const;
int getHealthCheckInterval()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getHealthCheckConnectTimeout()const;
int getBackendServerPort()const;
int getPersistenceTimeout()const;
int getHealthCheckConnectPort()const;
int getBandwidth()const;
int getHealthyThreshold()const;
std::string getHealthCheckDomain()const;
std::string getMasterSlaveServerGroupId()const;
std::string getHealthCheckHttpCode()const;
std::string getHealthCheckType()const;
int getEstablishedTimeout()const;
int getMaxConnection()const;
std::string getVServerGroupId()const;
std::string getSynProxy()const;
std::string getDescription()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getBackendServerPort()const;
int getPersistenceTimeout()const;
int getHealthCheckConnectPort()const;
int getBandwidth()const;
std::string getHealthCheckHttpCode()const;
int getEstablishedTimeout()const;
std::string getStatus()const;
int getListenerPort()const;
int getHealthCheckInterval()const;
std::string getAclId()const;
int getHealthCheckConnectTimeout()const;
std::string getAclStatus()const;
std::string getVpcIds()const;
int getHealthyThreshold()const;
std::string getHealthCheckDomain()const;
std::string getMasterSlaveServerGroupId()const;
std::string getAclType()const;
std::string getHealthCheckType()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
int maxConnection_;
int listenerPort_;
std::string vServerGroupId_;
std::string synProxy_;
int healthCheckInterval_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int healthCheckConnectTimeout_;
int backendServerPort_;
int persistenceTimeout_;
int healthCheckConnectPort_;
int bandwidth_;
int healthyThreshold_;
std::string healthCheckDomain_;
std::string masterSlaveServerGroupId_;
std::string healthCheckHttpCode_;
std::string healthCheckType_;
int establishedTimeout_;
int maxConnection_;
std::string vServerGroupId_;
std::string synProxy_;
std::string description_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int backendServerPort_;
int persistenceTimeout_;
int healthCheckConnectPort_;
int bandwidth_;
std::string healthCheckHttpCode_;
int establishedTimeout_;
std::string status_;
int listenerPort_;
int healthCheckInterval_;
std::string aclId_;
int healthCheckConnectTimeout_;
std::string aclStatus_;
std::string vpcIds_;
int healthyThreshold_;
std::string healthCheckDomain_;
std::string masterSlaveServerGroupId_;
std::string aclType_;
std::string healthCheckType_;
};
}

78
slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h
View File

@@ -37,44 +37,54 @@ namespace AlibabaCloud
DescribeLoadBalancerUDPListenerAttributeResult();
explicit DescribeLoadBalancerUDPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerUDPListenerAttributeResult();
std::string getStatus()const;
int getMaxConnection()const;
int getListenerPort()const;
std::string getVServerGroupId()const;
int getHealthCheckInterval()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheck()const;
int getHealthCheckConnectTimeout()const;
int getBackendServerPort()const;
int getPersistenceTimeout()const;
int getHealthCheckConnectPort()const;
std::string getHealthCheckReq()const;
int getBandwidth()const;
int getHealthyThreshold()const;
std::string getHealthCheckExp()const;
std::string getMasterSlaveServerGroupId()const;
std::string getStatus()const;
int getMaxConnection()const;
int getListenerPort()const;
std::string getVServerGroupId()const;
int getHealthCheckInterval()const;
std::string getDescription()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getAclId()const;
std::string getHealthCheck()const;
int getHealthCheckConnectTimeout()const;
int getBackendServerPort()const;
int getPersistenceTimeout()const;
int getHealthCheckConnectPort()const;
std::string getHealthCheckReq()const;
std::string getAclStatus()const;
std::string getVpcIds()const;
int getBandwidth()const;
int getHealthyThreshold()const;
std::string getHealthCheckExp()const;
std::string getMasterSlaveServerGroupId()const;
std::string getAclType()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
int maxConnection_;
int listenerPort_;
std::string vServerGroupId_;
int healthCheckInterval_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheck_;
int healthCheckConnectTimeout_;
int backendServerPort_;
int persistenceTimeout_;
int healthCheckConnectPort_;
std::string healthCheckReq_;
int bandwidth_;
int healthyThreshold_;
std::string healthCheckExp_;
std::string masterSlaveServerGroupId_;
std::string status_;
int maxConnection_;
int listenerPort_;
std::string vServerGroupId_;
int healthCheckInterval_;
std::string description_;
int unhealthyThreshold_;
std::string scheduler_;
std::string aclId_;
std::string healthCheck_;
int healthCheckConnectTimeout_;
int backendServerPort_;
int persistenceTimeout_;
int healthCheckConnectPort_;
std::string healthCheckReq_;
std::string aclStatus_;
std::string vpcIds_;
int bandwidth_;
int healthyThreshold_;
std::string healthCheckExp_;
std::string masterSlaveServerGroupId_;
std::string aclType_;
};
}

94
slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsResult.h
View File

@@ -32,62 +32,62 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRelatedEcsResult : public ServiceResult
{
public:
struct LoadBalancer
{
struct MasterSlaveVServerGroup
{
struct BackendServer
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string groupName;
std::vector<MasterSlaveVServerGroup::BackendServer> backendServers1;
std::string groupId;
};
struct VServerGroup
{
struct BackendServer3
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string groupName;
std::vector<VServerGroup::BackendServer3> backendServers2;
std::string groupId;
};
struct BackendServer4
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string loadBalancerId;
std::vector<LoadBalancer::MasterSlaveVServerGroup> masterSlaveVServerGroups;
std::vector<LoadBalancer::VServerGroup> vServerGroups;
int count;
std::vector<LoadBalancer::BackendServer4> backendServers;
};
struct LoadBalancer
{
struct MasterSlaveVServerGroup
{
struct BackendServer
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string groupName;
std::vector<MasterSlaveVServerGroup::BackendServer> backendServers1;
std::string groupId;
};
struct VServerGroup
{
struct BackendServer3
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string groupName;
std::vector<VServerGroup::BackendServer3> backendServers2;
std::string groupId;
};
struct BackendServer4
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string loadBalancerId;
std::vector<LoadBalancer::MasterSlaveVServerGroup> masterSlaveVServerGroups;
std::vector<LoadBalancer::VServerGroup> vServerGroups;
int count;
std::vector<LoadBalancer::BackendServer4> backendServers;
};
DescribeLoadBalancersRelatedEcsResult();
explicit DescribeLoadBalancersRelatedEcsResult(const std::string &payload);
~DescribeLoadBalancersRelatedEcsResult();
std::string getMessage()const;
std::vector<LoadBalancer> getLoadBalancers()const;
bool getSuccess()const;
std::string getMessage()const;
std::vector<LoadBalancer> getLoadBalancers()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<LoadBalancer> loadBalancers_;
bool success_;
std::string message_;
std::vector<LoadBalancer> loadBalancers_;
bool success_;
};
}

75
slb/include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h
View File

@@ -39,72 +39,81 @@ namespace AlibabaCloud
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAddress()const;
void setAddress(const std::string& address);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerId()const;
void setServerId(const std::string& serverId);
std::string getAddressIPVersion()const;
void setAddressIPVersion(const std::string& addressIPVersion);
std::string getMasterZoneId()const;
void setMasterZoneId(const std::string& masterZoneId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getServerIntranetAddress()const;
void setServerIntranetAddress(const std::string& serverIntranetAddress);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getSlaveZoneId()const;
void setSlaveZoneId(const std::string& slaveZoneId);
std::string getFuzzy()const;
void setFuzzy(const std::string& fuzzy);
std::string getAddress()const;
void setAddress(const std::string& address);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerId()const;
void setServerId(const std::string& serverId);
std::string getLoadBalancerStatus()const;
void setLoadBalancerStatus(const std::string& loadBalancerStatus);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getServerIntranetAddress()const;
void setServerIntranetAddress(const std::string& serverIntranetAddress);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getPayType()const;
void setPayType(const std::string& payType);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string address_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string networkType_;
long ownerId_;
std::string serverId_;
std::string addressIPVersion_;
std::string masterZoneId_;
int pageNumber_;
std::string tags_;
std::string serverIntranetAddress_;
std::string vSwitchId_;
std::string resourceGroupId_;
std::string loadBalancerName_;
std::string loadBalancerId_;
std::string regionId_;
std::string internetChargeType_;
std::string vpcId_;
int pageSize_;
std::string addressType_;
std::string slaveZoneId_;
std::string fuzzy_;
std::string address_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string serverId_;
std::string loadBalancerStatus_;
std::string tags_;
std::string serverIntranetAddress_;
std::string vSwitchId_;
std::string loadBalancerId_;
std::string internetChargeType_;
std::string vpcId_;
std::string payType_;
};

57
slb/include/alibabacloud/slb/model/DescribeLoadBalancersResult.h
View File

@@ -32,43 +32,44 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersResult : public ServiceResult
{
public:
struct LoadBalancer
{
std::string address;
std::string resourceGroupId;
std::string vSwitchId;
std::string createTime;
std::string loadBalancerId;
std::string payType;
std::string slaveZoneId;
std::string internetChargeType;
std::string regionIdAlias;
std::string loadBalancerName;
std::string vpcId;
std::string networkType;
std::string regionId;
std::string addressType;
std::string loadBalancerStatus;
std::string masterZoneId;
long createTimeStamp;
};
struct LoadBalancer
{
std::string address;
std::string resourceGroupId;
std::string vSwitchId;
std::string createTime;
std::string addressIPVersion;
std::string loadBalancerId;
std::string payType;
std::string slaveZoneId;
std::string internetChargeType;
std::string regionIdAlias;
std::string loadBalancerName;
std::string vpcId;
std::string networkType;
std::string regionId;
std::string addressType;
std::string loadBalancerStatus;
std::string masterZoneId;
long createTimeStamp;
};
DescribeLoadBalancersResult();
explicit DescribeLoadBalancersResult(const std::string &payload);
~DescribeLoadBalancersResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<LoadBalancer> getLoadBalancers()const;
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<LoadBalancer> getLoadBalancers()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<LoadBalancer> loadBalancers_;
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<LoadBalancer> loadBalancers_;
};
}

30
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h
View File

@@ -32,28 +32,32 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupAttributeResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverType;
std::string serverId;
int port;
int weight;
};
struct MasterSlaveBackendServer
{
std::string serverType;
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
DescribeMasterSlaveServerGroupAttributeResult();
explicit DescribeMasterSlaveServerGroupAttributeResult(const std::string &payload);
~DescribeMasterSlaveServerGroupAttributeResult();
std::string getMasterSlaveServerGroupId()const;
std::string getMasterSlaveServerGroupName()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
std::string getMasterSlaveServerGroupId()const;
std::string getMasterSlaveServerGroupName()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveServerGroupId_;
std::string masterSlaveServerGroupName_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveServerGroupId_;
std::string masterSlaveServerGroupName_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}

3
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h
View File

@@ -45,6 +45,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getIncludeListener()const;
void setIncludeListener(bool includeListener);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
@@ -58,6 +60,7 @@ namespace AlibabaCloud
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
bool includeListener_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;

24
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h
View File

@@ -32,22 +32,32 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupsResult : public ServiceResult
{
public:
struct MasterSlaveServerGroup
{
std::string masterSlaveServerGroupId;
std::string masterSlaveServerGroupName;
};
struct MasterSlaveServerGroup
{
struct AssociatedObjects
{
struct Listener
{
int port;
std::string protocol;
};
std::vector<Listener> listeners;
};
AssociatedObjects associatedObjects;
std::string masterSlaveServerGroupId;
std::string masterSlaveServerGroupName;
};
DescribeMasterSlaveServerGroupsResult();
explicit DescribeMasterSlaveServerGroupsResult(const std::string &payload);
~DescribeMasterSlaveServerGroupsResult();
std::vector<MasterSlaveServerGroup> getMasterSlaveServerGroups()const;
std::vector<MasterSlaveServerGroup> getMasterSlaveServerGroups()const;
protected:
void parse(const std::string &payload);
private:
std::vector<MasterSlaveServerGroup> masterSlaveServerGroups_;
std::vector<MasterSlaveServerGroup> masterSlaveServerGroups_;
};
}

30
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h
View File

@@ -32,28 +32,32 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverId;
int port;
int isBackup;
int weight;
};
struct MasterSlaveBackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int isBackup;
int weight;
};
DescribeMasterSlaveVServerGroupAttributeResult();
explicit DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload);
~DescribeMasterSlaveVServerGroupAttributeResult();
std::string getMasterSlaveVServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
std::string getMasterSlaveVServerGroupName()const;
std::string getMasterSlaveVServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
std::string getMasterSlaveVServerGroupName()const;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveVServerGroupName_;
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveVServerGroupName_;
};
}

14
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h
View File

@@ -32,22 +32,22 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsResult : public ServiceResult
{
public:
struct MasterSlaveVServerGroup
{
std::string masterSlaveVServerGroupId;
std::string masterSlaveVServerGroupName;
};
struct MasterSlaveVServerGroup
{
std::string masterSlaveVServerGroupId;
std::string masterSlaveVServerGroupName;
};
DescribeMasterSlaveVServerGroupsResult();
explicit DescribeMasterSlaveVServerGroupsResult(const std::string &payload);
~DescribeMasterSlaveVServerGroupsResult();
std::vector<MasterSlaveVServerGroup> getMasterSlaveVServerGroups()const;
std::vector<MasterSlaveVServerGroup> getMasterSlaveVServerGroups()const;
protected:
void parse(const std::string &payload);
private:
std::vector<MasterSlaveVServerGroup> masterSlaveVServerGroups_;
std::vector<MasterSlaveVServerGroup> masterSlaveVServerGroups_;
};
}

3
slb/include/alibabacloud/slb/model/DescribeRegionsRequest.h
View File

@@ -45,6 +45,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getAcceptLanguage()const;
void setAcceptLanguage(const std::string& acceptLanguage);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
@@ -56,6 +58,7 @@ namespace AlibabaCloud
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string acceptLanguage_;
long ownerId_;
std::string tags_;

15
slb/include/alibabacloud/slb/model/DescribeRegionsResult.h
View File

@@ -32,22 +32,23 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
std::string regionId;
std::string localName;
};
struct Region
{
std::string regionId;
std::string regionEndpoint;
std::string localName;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::vector<Region> getRegions()const;
std::vector<Region> getRegions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Region> regions_;
std::vector<Region> regions_;
};
}

54
slb/include/alibabacloud/slb/model/DescribeRuleAttributeResult.h
View File

@@ -37,22 +37,52 @@ namespace AlibabaCloud
DescribeRuleAttributeResult();
explicit DescribeRuleAttributeResult(const std::string &payload);
~DescribeRuleAttributeResult();
std::string getListenerPort()const;
std::string getVServerGroupId()const;
std::string getLoadBalancerId()const;
std::string getDomain()const;
std::string getRuleName()const;
std::string getUrl()const;
int getCookieTimeout()const;
std::string getCookie()const;
std::string getListenerPort()const;
std::string getVServerGroupId()const;
int getHealthCheckInterval()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
std::string getLoadBalancerId()const;
int getHealthCheckTimeout()const;
std::string getUrl()const;
std::string getStickySession()const;
int getHealthCheckConnectPort()const;
int getHealthyThreshold()const;
std::string getListenerSync()const;
std::string getHealthCheckDomain()const;
std::string getStickySessionType()const;
std::string getDomain()const;
std::string getHealthCheckHttpCode()const;
std::string getRuleName()const;
protected:
void parse(const std::string &payload);
private:
std::string listenerPort_;
std::string vServerGroupId_;
std::string loadBalancerId_;
std::string domain_;
std::string ruleName_;
std::string url_;
int cookieTimeout_;
std::string cookie_;
std::string listenerPort_;
std::string vServerGroupId_;
int healthCheckInterval_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
std::string loadBalancerId_;
int healthCheckTimeout_;
std::string url_;
std::string stickySession_;
int healthCheckConnectPort_;
int healthyThreshold_;
std::string listenerSync_;
std::string healthCheckDomain_;
std::string stickySessionType_;
std::string domain_;
std::string healthCheckHttpCode_;
std::string ruleName_;
};
}

35
slb/include/alibabacloud/slb/model/DescribeRulesResult.h
View File

@@ -32,25 +32,40 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeRulesResult : public ServiceResult
{
public:
struct Rule
{
std::string vServerGroupId;
std::string ruleId;
std::string domain;
std::string ruleName;
std::string url;
};
struct Rule
{
int cookieTimeout;
std::string cookie;
std::string vServerGroupId;
int healthCheckInterval;
int unhealthyThreshold;
std::string scheduler;
std::string healthCheckURI;
std::string ruleId;
std::string healthCheck;
int healthCheckTimeout;
std::string url;
std::string stickySession;
int healthCheckConnectPort;
int healthyThreshold;
std::string listenerSync;
std::string healthCheckDomain;
std::string stickySessionType;
std::string domain;
std::string healthCheckHttpCode;
std::string ruleName;
};
DescribeRulesResult();
explicit DescribeRulesResult(const std::string &payload);
~DescribeRulesResult();
std::vector<Rule> getRules()const;
std::vector<Rule> getRules()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Rule> rules_;
std::vector<Rule> rules_;
};
}

36
slb/include/alibabacloud/slb/model/DescribeServerCertificatesResult.h
View File

@@ -32,31 +32,35 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeServerCertificatesResult : public ServiceResult
{
public:
struct ServerCertificate
{
std::string regionIdAlias;
std::string fingerprint;
std::string aliCloudCertificateName;
std::string resourceGroupId;
int isAliCloudCertificate;
std::string createTime;
std::string serverCertificateId;
std::string serverCertificateName;
std::string regionId;
long createTimeStamp;
std::string aliCloudCertificateId;
};
struct ServerCertificate
{
std::string fingerprint;
std::string resourceGroupId;
long expireTimeStamp;
std::string createTime;
std::vector<std::string> subjectAlternativeNames;
std::string aliCloudCertificateId;
std::string regionIdAlias;
std::string aliCloudCertificateName;
int isAliCloudCertificate;
std::string serverCertificateId;
std::string serverCertificateName;
std::string regionId;
std::string expireTime;
long createTimeStamp;
std::string commonName;
};
DescribeServerCertificatesResult();
explicit DescribeServerCertificatesResult(const std::string &payload);
~DescribeServerCertificatesResult();
std::vector<ServerCertificate> getServerCertificates()const;
std::vector<ServerCertificate> getServerCertificates()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ServerCertificate> serverCertificates_;
std::vector<ServerCertificate> serverCertificates_;
};
}

66
slb/include/alibabacloud/slb/model/DescribeSlbQuotasRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBESLBQUOTASREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBESLBQUOTASREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeSlbQuotasRequest : public RpcServiceRequest
{
public:
DescribeSlbQuotasRequest();
~DescribeSlbQuotasRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESLBQUOTASREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeSlbQuotasResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBESLBQUOTASRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBESLBQUOTASRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeSlbQuotasResult : public ServiceResult
{
public:
struct Quota
{
std::string quotaName;
std::string comment;
std::string max;
};
DescribeSlbQuotasResult();
explicit DescribeSlbQuotasResult(const std::string &payload);
~DescribeSlbQuotasResult();
std::vector<Quota> getQuotas()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Quota> quotas_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESLBQUOTASRESULT_H_

28
slb/include/alibabacloud/slb/model/DescribeTagsResult.h
View File

@@ -32,29 +32,29 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeTagsResult : public ServiceResult
{
public:
struct TagSet
{
int instanceCount;
std::string tagKey;
std::string tagValue;
};
struct TagSet
{
int instanceCount;
std::string tagKey;
std::string tagValue;
};
DescribeTagsResult();
explicit DescribeTagsResult(const std::string &payload);
~DescribeTagsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<TagSet> getTagSets()const;
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<TagSet> getTagSets()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<TagSet> tagSets_;
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<TagSet> tagSets_;
};
}

28
slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h
View File

@@ -32,27 +32,31 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupAttributeResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
DescribeVServerGroupAttributeResult();
explicit DescribeVServerGroupAttributeResult(const std::string &payload);
~DescribeVServerGroupAttributeResult();
std::string getVServerGroupId()const;
std::string getVServerGroupName()const;
std::vector<BackendServer> getBackendServers()const;
std::string getVServerGroupId()const;
std::string getVServerGroupName()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::string vServerGroupName_;
std::vector<BackendServer> backendServers_;
std::string vServerGroupId_;
std::string vServerGroupName_;
std::vector<BackendServer> backendServers_;
};
}

6
slb/include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h
View File

@@ -37,6 +37,8 @@ namespace AlibabaCloud
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
bool getIncludeRule()const;
void setIncludeRule(bool includeRule);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
@@ -45,6 +47,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getIncludeListener()const;
void setIncludeListener(bool includeListener);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
@@ -54,10 +58,12 @@ namespace AlibabaCloud
private:
std::string access_key_id_;
bool includeRule_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
bool includeListener_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;

32
slb/include/alibabacloud/slb/model/DescribeVServerGroupsResult.h
View File

@@ -32,22 +32,40 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupsResult : public ServiceResult
{
public:
struct VServerGroup
{
std::string vServerGroupId;
std::string vServerGroupName;
};
struct VServerGroup
{
struct AssociatedObjects
{
struct Listener
{
int port;
std::string protocol;
};
struct Rule
{
std::string ruleId;
std::string domain;
std::string url;
std::string ruleName;
};
std::vector<Listener> listeners;
std::vector<Rule> rules;
};
std::string vServerGroupId;
AssociatedObjects associatedObjects;
std::string vServerGroupName;
};
DescribeVServerGroupsResult();
explicit DescribeVServerGroupsResult(const std::string &payload);
~DescribeVServerGroupsResult();
std::vector<VServerGroup> getVServerGroups()const;
std::vector<VServerGroup> getVServerGroups()const;
protected:
void parse(const std::string &payload);
private:
std::vector<VServerGroup> vServerGroups_;
std::vector<VServerGroup> vServerGroups_;
};
}

26
slb/include/alibabacloud/slb/model/DescribeZonesResult.h
View File

@@ -32,28 +32,28 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeZonesResult : public ServiceResult
{
public:
struct Zone
{
struct SlaveZone
{
std::string zoneId;
std::string localName;
};
std::vector<Zone::SlaveZone> slaveZones;
std::string zoneId;
std::string localName;
};
struct Zone
{
struct SlaveZone
{
std::string zoneId;
std::string localName;
};
std::vector<Zone::SlaveZone> slaveZones;
std::string zoneId;
std::string localName;
};
DescribeZonesResult();
explicit DescribeZonesResult(const std::string &payload);
~DescribeZonesResult();
std::vector<Zone> getZones()const;
std::vector<Zone> getZones()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Zone> zones_;
std::vector<Zone> zones_;
};
}

4
slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h
View File

@@ -37,12 +37,12 @@ namespace AlibabaCloud
ModifyLoadBalancerInstanceSpecResult();
explicit ModifyLoadBalancerInstanceSpecResult(const std::string &payload);
~ModifyLoadBalancerInstanceSpecResult();
long getOrderId()const;
long getOrderId()const;
protected:
void parse(const std::string &payload);
private:
long orderId_;
long orderId_;
};
}

4
slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h
View File

@@ -37,12 +37,12 @@ namespace AlibabaCloud
ModifyLoadBalancerInternetSpecResult();
explicit ModifyLoadBalancerInternetSpecResult(const std::string &payload);
~ModifyLoadBalancerInternetSpecResult();
long getOrderId()const;
long getOrderId()const;
protected:
void parse(const std::string &payload);
private:
long orderId_;
long orderId_;
};
}

4
slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h
View File

@@ -37,12 +37,12 @@ namespace AlibabaCloud
ModifyLoadBalancerPayTypeResult();
explicit ModifyLoadBalancerPayTypeResult(const std::string &payload);
~ModifyLoadBalancerPayTypeResult();
long getOrderId()const;
long getOrderId()const;
protected:
void parse(const std::string &payload);
private:
long orderId_;
long orderId_;
};
}

24
slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h
View File

@@ -32,25 +32,29 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT ModifyVServerGroupBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
ModifyVServerGroupBackendServersResult();
explicit ModifyVServerGroupBackendServersResult(const std::string &payload);
~ModifyVServerGroupBackendServersResult();
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}

75
slb/include/alibabacloud/slb/model/RemoveAccessControlListEntryRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_REMOVEACCESSCONTROLLISTENTRYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_REMOVEACCESSCONTROLLISTENTRYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT RemoveAccessControlListEntryRequest : public RpcServiceRequest
{
public:
RemoveAccessControlListEntryRequest();
~RemoveAccessControlListEntryRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getAclId()const;
void setAclId(const std::string& aclId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getAclEntrys()const;
void setAclEntrys(const std::string& aclEntrys);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string aclId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string aclEntrys_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_REMOVEACCESSCONTROLLISTENTRYREQUEST_H_

49
slb/include/alibabacloud/slb/model/RemoveAccessControlListEntryResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_REMOVEACCESSCONTROLLISTENTRYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_REMOVEACCESSCONTROLLISTENTRYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT RemoveAccessControlListEntryResult : public ServiceResult
{
public:
RemoveAccessControlListEntryResult();
explicit RemoveAccessControlListEntryResult(const std::string &payload);
~RemoveAccessControlListEntryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_REMOVEACCESSCONTROLLISTENTRYRESULT_H_

21
slb/include/alibabacloud/slb/model/RemoveBackendServersResult.h
View File

@@ -32,24 +32,27 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT RemoveBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string serverIp;
int weight;
};
RemoveBackendServersResult();
explicit RemoveBackendServersResult(const std::string &payload);
~RemoveBackendServersResult();
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
};
}

24
slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h
View File

@@ -32,25 +32,29 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT RemoveVServerGroupBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
RemoveVServerGroupBackendServersResult();
explicit RemoveVServerGroupBackendServersResult(const std::string &payload);
~RemoveVServerGroupBackendServersResult();
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}

75
slb/include/alibabacloud/slb/model/SetAccessControlListAttributeRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_SETACCESSCONTROLLISTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETACCESSCONTROLLISTATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetAccessControlListAttributeRequest : public RpcServiceRequest
{
public:
SetAccessControlListAttributeRequest();
~SetAccessControlListAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getAclId()const;
void setAclId(const std::string& aclId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAclName()const;
void setAclName(const std::string& aclName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string aclId_;
long resourceOwnerId_;
std::string aclName_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETACCESSCONTROLLISTATTRIBUTEREQUEST_H_

51
slb/include/alibabacloud/slb/model/SetAccessControlListAttributeResult.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_SLB_MODEL_SETACCESSCONTROLLISTATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETACCESSCONTROLLISTATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetAccessControlListAttributeResult : public ServiceResult
{
public:
SetAccessControlListAttributeResult();
explicit SetAccessControlListAttributeResult(const std::string &payload);
~SetAccessControlListAttributeResult();
std::string getAclId()const;
protected:
void parse(const std::string &payload);
private:
std::string aclId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETACCESSCONTROLLISTATTRIBUTERESULT_H_

78
slb/include/alibabacloud/slb/model/SetAutoRenewStatusRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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_SLB_MODEL_SETAUTORENEWSTATUSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETAUTORENEWSTATUSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetAutoRenewStatusRequest : public RpcServiceRequest
{
public:
SetAutoRenewStatusRequest();
~SetAutoRenewStatusRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getRenewalDuration()const;
void setRenewalDuration(int renewalDuration);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getRenewalStatus()const;
void setRenewalStatus(const std::string& renewalStatus);
std::string getRenewalCycUnit()const;
void setRenewalCycUnit(const std::string& renewalCycUnit);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int renewalDuration_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string renewalStatus_;
std::string renewalCycUnit_;
long ownerId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETAUTORENEWSTATUSREQUEST_H_

49
slb/include/alibabacloud/slb/model/SetAutoRenewStatusResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_SETAUTORENEWSTATUSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETAUTORENEWSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetAutoRenewStatusResult : public ServiceResult
{
public:
SetAutoRenewStatusResult();
explicit SetAutoRenewStatusResult(const std::string &payload);
~SetAutoRenewStatusResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETAUTORENEWSTATUSRESULT_H_

22
slb/include/alibabacloud/slb/model/SetBackendServersResult.h
View File

@@ -32,24 +32,28 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT SetBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
std::string weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
std::string serverIp;
std::string weight;
};
SetBackendServersResult();
explicit SetBackendServersResult(const std::string &payload);
~SetBackendServersResult();
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
};
}

72
slb/include/alibabacloud/slb/model/SetDomainExtensionAttributeRequest.h 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.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_SETDOMAINEXTENSIONATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETDOMAINEXTENSIONATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetDomainExtensionAttributeRequest : public RpcServiceRequest
{
public:
SetDomainExtensionAttributeRequest();
~SetDomainExtensionAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
void setServerCertificateId(const std::string& serverCertificateId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getDomainExtensionId()const;
void setDomainExtensionId(const std::string& domainExtensionId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string serverCertificateId_;
std::string tags_;
std::string domainExtensionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETDOMAINEXTENSIONATTRIBUTEREQUEST_H_

49
slb/include/alibabacloud/slb/model/SetDomainExtensionAttributeResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_SETDOMAINEXTENSIONATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETDOMAINEXTENSIONATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetDomainExtensionAttributeResult : public ServiceResult
{
public:
SetDomainExtensionAttributeResult();
explicit SetDomainExtensionAttributeResult(const std::string &payload);
~SetDomainExtensionAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETDOMAINEXTENSIONATTRIBUTERESULT_H_

21
slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h
View File

@@ -45,12 +45,18 @@ namespace AlibabaCloud
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getMaxConnection()const;
@@ -61,8 +67,12 @@ namespace AlibabaCloud
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getCookie()const;
@@ -75,6 +85,8 @@ namespace AlibabaCloud
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
int getRequestTimeout()const;
void setRequestTimeout(int requestTimeout);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getGzip()const;
@@ -83,6 +95,8 @@ namespace AlibabaCloud
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
int getIdleTimeout()const;
void setIdleTimeout(int idleTimeout);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getXForwardedFor_SLBIP()const;
@@ -106,25 +120,32 @@ namespace AlibabaCloud
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
std::string healthCheck_;
int maxConnection_;
std::string regionId_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string cookie_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string healthCheckDomain_;
int requestTimeout_;
std::string ownerAccount_;
std::string gzip_;
long ownerId_;
std::string tags_;
int idleTimeout_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int healthCheckInterval_;

27
slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h
View File

@@ -45,24 +45,36 @@ namespace AlibabaCloud
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getEnableHttp2()const;
void setEnableHttp2(const std::string& enableHttp2);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getCookie()const;
@@ -75,10 +87,14 @@ namespace AlibabaCloud
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
int getRequestTimeout()const;
void setRequestTimeout(int requestTimeout);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getGzip()const;
void setGzip(const std::string& gzip);
std::string getTLSCipherPolicy()const;
void setTLSCipherPolicy(const std::string& tLSCipherPolicy);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
@@ -87,6 +103,8 @@ namespace AlibabaCloud
void setCACertificateId(const std::string& cACertificateId);
std::string getTags()const;
void setTags(const std::string& tags);
int getIdleTimeout()const;
void setIdleTimeout(int idleTimeout);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getXForwardedFor_SLBIP()const;
@@ -110,27 +128,36 @@ namespace AlibabaCloud
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
std::string healthCheck_;
int maxConnection_;
std::string enableHttp2_;
std::string regionId_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string cookie_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string healthCheckDomain_;
int requestTimeout_;
std::string ownerAccount_;
std::string gzip_;
std::string tLSCipherPolicy_;
long ownerId_;
std::string serverCertificateId_;
std::string cACertificateId_;
std::string tags_;
int idleTimeout_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int healthCheckInterval_;

15
slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h
View File

@@ -43,12 +43,18 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
std::string getMasterSlaveServerGroup()const;
void setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup);
int getEstablishedTimeout()const;
@@ -59,8 +65,12 @@ namespace AlibabaCloud
void setRegionId(const std::string& regionId);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getHealthCheckType()const;
@@ -97,15 +107,20 @@ namespace AlibabaCloud
int healthCheckConnectTimeout_;
long resourceOwnerId_;
std::string healthCheckURI_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
std::string masterSlaveServerGroup_;
int establishedTimeout_;
int maxConnection_;
std::string regionId_;
int persistenceTimeout_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;

15
slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h
View File

@@ -41,12 +41,18 @@ namespace AlibabaCloud
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDescription()const;
void setDescription(const std::string& description);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAclStatus()const;
void setAclStatus(const std::string& aclStatus);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getAclType()const;
void setAclType(const std::string& aclType);
std::string getMasterSlaveServerGroup()const;
void setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup);
int getMaxConnection()const;
@@ -55,8 +61,12 @@ namespace AlibabaCloud
void setRegionId(const std::string& regionId);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVpcIds()const;
void setVpcIds(const std::string& vpcIds);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getAclId()const;
void setAclId(const std::string& aclId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount()const;
@@ -88,14 +98,19 @@ namespace AlibabaCloud
std::string access_key_id_;
int healthCheckConnectTimeout_;
long resourceOwnerId_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string aclStatus_;
std::string scheduler_;
std::string aclType_;
std::string masterSlaveServerGroup_;
int maxConnection_;
std::string regionId_;
int persistenceTimeout_;
std::string vpcIds_;
std::string vServerGroupId_;
std::string aclId_;
int listenerPort_;
std::string resourceOwnerAccount_;
int bandwidth_;

66
slb/include/alibabacloud/slb/model/SetRuleRequest.h
View File

@@ -37,33 +37,81 @@ namespace AlibabaCloud
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getRuleName()const;
void setRuleName(const std::string& ruleName);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getListenerSync()const;
void setListenerSync(const std::string& listenerSync);
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getCookie()const;
void setCookie(const std::string& cookie);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getStickySession()const;
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getRuleId()const;
void setRuleId(const std::string& ruleId);
std::string getTags()const;
void setTags(const std::string& tags);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getRuleId()const;
void setRuleId(const std::string& ruleId);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
private:
std::string access_key_id_;
std::string vServerGroupId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
int healthCheckTimeout_;
std::string healthCheckURI_;
std::string ruleName_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
std::string healthCheck_;
std::string regionId_;
std::string listenerSync_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vServerGroupId_;
std::string cookie_;
std::string resourceOwnerAccount_;
std::string stickySession_;
std::string healthCheckDomain_;
std::string ownerAccount_;
long ownerId_;
std::string ruleId_;
std::string tags_;
int healthCheckInterval_;
std::string ruleId_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
}

28
slb/include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h
View File

@@ -32,27 +32,31 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT SetVServerGroupAttributeResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
struct BackendServer
{
std::string type;
std::string serverId;
std::string vpcId;
std::string eniHost;
int port;
std::string serverIp;
int weight;
};
SetVServerGroupAttributeResult();
explicit SetVServerGroupAttributeResult(const std::string &payload);
~SetVServerGroupAttributeResult();
std::string getVServerGroupId()const;
std::string getVServerGroupName()const;
std::vector<BackendServer> getBackendServers()const;
std::string getVServerGroupId()const;
std::string getVServerGroupName()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::string vServerGroupName_;
std::vector<BackendServer> backendServers_;
std::string vServerGroupId_;
std::string vServerGroupName_;
std::vector<BackendServer> backendServers_;
};
}

30
slb/include/alibabacloud/slb/model/UploadCACertificateResult.h
View File

@@ -37,22 +37,28 @@ namespace AlibabaCloud
UploadCACertificateResult();
explicit UploadCACertificateResult(const std::string &payload);
~UploadCACertificateResult();
std::string getFingerprint()const;
std::string getResourceGroupId()const;
std::string getCACertificateId()const;
std::string getCreateTime()const;
std::string getCACertificateName()const;
long getCreateTimeStamp()const;
std::string getFingerprint()const;
std::string getResourceGroupId()const;
long getExpireTimeStamp()const;
std::string getCACertificateId()const;
std::string getCreateTime()const;
std::string getCACertificateName()const;
std::string getExpireTime()const;
long getCreateTimeStamp()const;
std::string getCommonName()const;
protected:
void parse(const std::string &payload);
private:
std::string fingerprint_;
std::string resourceGroupId_;
std::string cACertificateId_;
std::string createTime_;
std::string cACertificateName_;
long createTimeStamp_;
std::string fingerprint_;
std::string resourceGroupId_;
long expireTimeStamp_;
std::string cACertificateId_;
std::string createTime_;
std::string cACertificateName_;
std::string expireTime_;
long createTimeStamp_;
std::string commonName_;
};
}

52
slb/include/alibabacloud/slb/model/UploadServerCertificateResult.h
View File

@@ -37,32 +37,40 @@ namespace AlibabaCloud
UploadServerCertificateResult();
explicit UploadServerCertificateResult(const std::string &payload);
~UploadServerCertificateResult();
std::string getRegionIdAlias()const;
std::string getFingerprint()const;
std::string getAliCloudCertificateName()const;
std::string getResourceGroupId()const;
int getIsAliCloudCertificate()const;
std::string getCreateTime()const;
std::string getServerCertificateId()const;
std::string getServerCertificateName()const;
std::string getRegionId()const;
long getCreateTimeStamp()const;
std::string getAliCloudCertificateId()const;
std::string getFingerprint()const;
std::string getResourceGroupId()const;
long getExpireTimeStamp()const;
std::string getCreateTime()const;
std::vector<std::string> getSubjectAlternativeNames()const;
std::string getAliCloudCertificateId()const;
std::string getRegionIdAlias()const;
std::string getAliCloudCertificateName()const;
int getIsAliCloudCertificate()const;
std::string getServerCertificateId()const;
std::string getServerCertificateName()const;
std::string getRegionId()const;
std::string getExpireTime()const;
long getCreateTimeStamp()const;
std::string getCommonName()const;
protected:
void parse(const std::string &payload);
private:
std::string regionIdAlias_;
std::string fingerprint_;
std::string aliCloudCertificateName_;
std::string resourceGroupId_;
int isAliCloudCertificate_;
std::string createTime_;
std::string serverCertificateId_;
std::string serverCertificateName_;
std::string regionId_;
long createTimeStamp_;
std::string aliCloudCertificateId_;
std::string fingerprint_;
std::string resourceGroupId_;
long expireTimeStamp_;
std::string createTime_;
std::vector<std::string> subjectAlternativeNames_;
std::string aliCloudCertificateId_;
std::string regionIdAlias_;
std::string aliCloudCertificateName_;
int isAliCloudCertificate_;
std::string serverCertificateId_;
std::string serverCertificateName_;
std::string regionId_;
std::string expireTime_;
long createTimeStamp_;
std::string commonName_;
};
}

468
slb/src/SlbClient.cc
View File

@@ -51,6 +51,42 @@ SlbClient::SlbClient(const std::string & accessKeyId, const std::string & access
SlbClient::~SlbClient()
{}
SlbClient::SetDomainExtensionAttributeOutcome SlbClient::setDomainExtensionAttribute(const SetDomainExtensionAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetDomainExtensionAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetDomainExtensionAttributeOutcome(SetDomainExtensionAttributeResult(outcome.result()));
else
return SetDomainExtensionAttributeOutcome(outcome.error());
}
void SlbClient::setDomainExtensionAttributeAsync(const SetDomainExtensionAttributeRequest& request, const SetDomainExtensionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setDomainExtensionAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetDomainExtensionAttributeOutcomeCallable SlbClient::setDomainExtensionAttributeCallable(const SetDomainExtensionAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetDomainExtensionAttributeOutcome()>>(
[this, request]()
{
return this->setDomainExtensionAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateLoadBalancerUDPListenerOutcome SlbClient::createLoadBalancerUDPListener(const CreateLoadBalancerUDPListenerRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,6 +663,42 @@ SlbClient::SetLoadBalancerHTTPListenerAttributeOutcomeCallable SlbClient::setLoa
return task->get_future();
}
SlbClient::DescribeDomainExtensionsOutcome SlbClient::describeDomainExtensions(const DescribeDomainExtensionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDomainExtensionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDomainExtensionsOutcome(DescribeDomainExtensionsResult(outcome.result()));
else
return DescribeDomainExtensionsOutcome(outcome.error());
}
void SlbClient::describeDomainExtensionsAsync(const DescribeDomainExtensionsRequest& request, const DescribeDomainExtensionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDomainExtensions(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeDomainExtensionsOutcomeCallable SlbClient::describeDomainExtensionsCallable(const DescribeDomainExtensionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDomainExtensionsOutcome()>>(
[this, request]()
{
return this->describeDomainExtensions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::SetLoadBalancerAutoReleaseTimeOutcome SlbClient::setLoadBalancerAutoReleaseTime(const SetLoadBalancerAutoReleaseTimeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +879,42 @@ SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::setLo
return task->get_future();
}
SlbClient::SetAutoRenewStatusOutcome SlbClient::setAutoRenewStatus(const SetAutoRenewStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetAutoRenewStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetAutoRenewStatusOutcome(SetAutoRenewStatusResult(outcome.result()));
else
return SetAutoRenewStatusOutcome(outcome.error());
}
void SlbClient::setAutoRenewStatusAsync(const SetAutoRenewStatusRequest& request, const SetAutoRenewStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setAutoRenewStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetAutoRenewStatusOutcomeCallable SlbClient::setAutoRenewStatusCallable(const SetAutoRenewStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetAutoRenewStatusOutcome()>>(
[this, request]()
{
return this->setAutoRenewStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DeleteLoadBalancerListenerOutcome SlbClient::deleteLoadBalancerListener(const DeleteLoadBalancerListenerRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1347,42 @@ SlbClient::RemoveBackendServersOutcomeCallable SlbClient::removeBackendServersCa
return task->get_future();
}
SlbClient::AddAccessControlListEntryOutcome SlbClient::addAccessControlListEntry(const AddAccessControlListEntryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddAccessControlListEntryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddAccessControlListEntryOutcome(AddAccessControlListEntryResult(outcome.result()));
else
return AddAccessControlListEntryOutcome(outcome.error());
}
void SlbClient::addAccessControlListEntryAsync(const AddAccessControlListEntryRequest& request, const AddAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addAccessControlListEntry(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::AddAccessControlListEntryOutcomeCallable SlbClient::addAccessControlListEntryCallable(const AddAccessControlListEntryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddAccessControlListEntryOutcome()>>(
[this, request]()
{
return this->addAccessControlListEntry(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::ModifyVServerGroupBackendServersOutcome SlbClient::modifyVServerGroupBackendServers(const ModifyVServerGroupBackendServersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1275,6 +1419,42 @@ SlbClient::ModifyVServerGroupBackendServersOutcomeCallable SlbClient::modifyVSer
return task->get_future();
}
SlbClient::DescribeSlbQuotasOutcome SlbClient::describeSlbQuotas(const DescribeSlbQuotasRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeSlbQuotasOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeSlbQuotasOutcome(DescribeSlbQuotasResult(outcome.result()));
else
return DescribeSlbQuotasOutcome(outcome.error());
}
void SlbClient::describeSlbQuotasAsync(const DescribeSlbQuotasRequest& request, const DescribeSlbQuotasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeSlbQuotas(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeSlbQuotasOutcomeCallable SlbClient::describeSlbQuotasCallable(const DescribeSlbQuotasRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeSlbQuotasOutcome()>>(
[this, request]()
{
return this->describeSlbQuotas(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeLoadBalancerUDPListenerAttributeOutcome SlbClient::describeLoadBalancerUDPListenerAttribute(const DescribeLoadBalancerUDPListenerAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1671,42 @@ SlbClient::SetBackendServersOutcomeCallable SlbClient::setBackendServersCallable
return task->get_future();
}
SlbClient::DeleteAccessControlListOutcome SlbClient::deleteAccessControlList(const DeleteAccessControlListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteAccessControlListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteAccessControlListOutcome(DeleteAccessControlListResult(outcome.result()));
else
return DeleteAccessControlListOutcome(outcome.error());
}
void SlbClient::deleteAccessControlListAsync(const DeleteAccessControlListRequest& request, const DeleteAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteAccessControlList(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DeleteAccessControlListOutcomeCallable SlbClient::deleteAccessControlListCallable(const DeleteAccessControlListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteAccessControlListOutcome()>>(
[this, request]()
{
return this->deleteAccessControlList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::RemoveVServerGroupBackendServersOutcome SlbClient::removeVServerGroupBackendServers(const RemoveVServerGroupBackendServersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1887,42 @@ SlbClient::DeleteCACertificateOutcomeCallable SlbClient::deleteCACertificateCall
return task->get_future();
}
SlbClient::SetAccessControlListAttributeOutcome SlbClient::setAccessControlListAttribute(const SetAccessControlListAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetAccessControlListAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetAccessControlListAttributeOutcome(SetAccessControlListAttributeResult(outcome.result()));
else
return SetAccessControlListAttributeOutcome(outcome.error());
}
void SlbClient::setAccessControlListAttributeAsync(const SetAccessControlListAttributeRequest& request, const SetAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setAccessControlListAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetAccessControlListAttributeOutcomeCallable SlbClient::setAccessControlListAttributeCallable(const SetAccessControlListAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetAccessControlListAttributeOutcome()>>(
[this, request]()
{
return this->setAccessControlListAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateLoadBalancerTCPListenerOutcome SlbClient::createLoadBalancerTCPListener(const CreateLoadBalancerTCPListenerRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +1959,114 @@ SlbClient::CreateLoadBalancerTCPListenerOutcomeCallable SlbClient::createLoadBal
return task->get_future();
}
SlbClient::DescribeAccessControlListAttributeOutcome SlbClient::describeAccessControlListAttribute(const DescribeAccessControlListAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeAccessControlListAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeAccessControlListAttributeOutcome(DescribeAccessControlListAttributeResult(outcome.result()));
else
return DescribeAccessControlListAttributeOutcome(outcome.error());
}
void SlbClient::describeAccessControlListAttributeAsync(const DescribeAccessControlListAttributeRequest& request, const DescribeAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeAccessControlListAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeAccessControlListAttributeOutcomeCallable SlbClient::describeAccessControlListAttributeCallable(const DescribeAccessControlListAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeAccessControlListAttributeOutcome()>>(
[this, request]()
{
return this->describeAccessControlListAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeAccessControlListsOutcome SlbClient::describeAccessControlLists(const DescribeAccessControlListsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeAccessControlListsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeAccessControlListsOutcome(DescribeAccessControlListsResult(outcome.result()));
else
return DescribeAccessControlListsOutcome(outcome.error());
}
void SlbClient::describeAccessControlListsAsync(const DescribeAccessControlListsRequest& request, const DescribeAccessControlListsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeAccessControlLists(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeAccessControlListsOutcomeCallable SlbClient::describeAccessControlListsCallable(const DescribeAccessControlListsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeAccessControlListsOutcome()>>(
[this, request]()
{
return this->describeAccessControlLists(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DeleteDomainExtensionOutcome SlbClient::deleteDomainExtension(const DeleteDomainExtensionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDomainExtensionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDomainExtensionOutcome(DeleteDomainExtensionResult(outcome.result()));
else
return DeleteDomainExtensionOutcome(outcome.error());
}
void SlbClient::deleteDomainExtensionAsync(const DeleteDomainExtensionRequest& request, const DeleteDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDomainExtension(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DeleteDomainExtensionOutcomeCallable SlbClient::deleteDomainExtensionCallable(const DeleteDomainExtensionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDomainExtensionOutcome()>>(
[this, request]()
{
return this->deleteDomainExtension(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::SetRuleOutcome SlbClient::setRule(const SetRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2031,6 +2391,78 @@ SlbClient::DescribeRulesOutcomeCallable SlbClient::describeRulesCallable(const D
return task->get_future();
}
SlbClient::RemoveAccessControlListEntryOutcome SlbClient::removeAccessControlListEntry(const RemoveAccessControlListEntryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RemoveAccessControlListEntryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RemoveAccessControlListEntryOutcome(RemoveAccessControlListEntryResult(outcome.result()));
else
return RemoveAccessControlListEntryOutcome(outcome.error());
}
void SlbClient::removeAccessControlListEntryAsync(const RemoveAccessControlListEntryRequest& request, const RemoveAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, removeAccessControlListEntry(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::RemoveAccessControlListEntryOutcomeCallable SlbClient::removeAccessControlListEntryCallable(const RemoveAccessControlListEntryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RemoveAccessControlListEntryOutcome()>>(
[this, request]()
{
return this->removeAccessControlListEntry(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateDomainExtensionOutcome SlbClient::createDomainExtension(const CreateDomainExtensionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDomainExtensionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDomainExtensionOutcome(CreateDomainExtensionResult(outcome.result()));
else
return CreateDomainExtensionOutcome(outcome.error());
}
void SlbClient::createDomainExtensionAsync(const CreateDomainExtensionRequest& request, const CreateDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDomainExtension(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::CreateDomainExtensionOutcomeCallable SlbClient::createDomainExtensionCallable(const CreateDomainExtensionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDomainExtensionOutcome()>>(
[this, request]()
{
return this->createDomainExtension(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeRuleAttributeOutcome SlbClient::describeRuleAttribute(const DescribeRuleAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2715,42 @@ SlbClient::ModifyLoadBalancerInternetSpecOutcomeCallable SlbClient::modifyLoadBa
return task->get_future();
}
SlbClient::CreateAccessControlListOutcome SlbClient::createAccessControlList(const CreateAccessControlListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateAccessControlListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateAccessControlListOutcome(CreateAccessControlListResult(outcome.result()));
else
return CreateAccessControlListOutcome(outcome.error());
}
void SlbClient::createAccessControlListAsync(const CreateAccessControlListRequest& request, const CreateAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createAccessControlList(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::CreateAccessControlListOutcomeCallable SlbClient::createAccessControlListCallable(const CreateAccessControlListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateAccessControlListOutcome()>>(
[this, request]()
{
return this->createAccessControlList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcome SlbClient::describeLoadBalancerHTTPSListenerAttribute(const DescribeLoadBalancerHTTPSListenerAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

137
slb/src/model/AddAccessControlListEntryRequest.cc Normal file
View File

@@ -0,0 +1,137 @@
/*
* 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/slb/model/AddAccessControlListEntryRequest.h>
using AlibabaCloud::Slb::Model::AddAccessControlListEntryRequest;
AddAccessControlListEntryRequest::AddAccessControlListEntryRequest() :
RpcServiceRequest("slb", "2014-05-15", "AddAccessControlListEntry")
{}
AddAccessControlListEntryRequest::~AddAccessControlListEntryRequest()
{}
std::string AddAccessControlListEntryRequest::getAccess_key_id()const
{
return access_key_id_;
}
void AddAccessControlListEntryRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
std::string AddAccessControlListEntryRequest::getAclId()const
{
return aclId_;
}
void AddAccessControlListEntryRequest::setAclId(const std::string& aclId)
{
aclId_ = aclId;
setParameter("AclId", aclId);
}
long AddAccessControlListEntryRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AddAccessControlListEntryRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AddAccessControlListEntryRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AddAccessControlListEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddAccessControlListEntryRequest::getRegionId()const
{
return regionId_;
}
void AddAccessControlListEntryRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string AddAccessControlListEntryRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AddAccessControlListEntryRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AddAccessControlListEntryRequest::getAclEntrys()const
{
return aclEntrys_;
}
void AddAccessControlListEntryRequest::setAclEntrys(const std::string& aclEntrys)
{
aclEntrys_ = aclEntrys;
setParameter("AclEntrys", aclEntrys);
}
long AddAccessControlListEntryRequest::getOwnerId()const
{
return ownerId_;
}
void AddAccessControlListEntryRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddAccessControlListEntryRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddAccessControlListEntryRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddAccessControlListEntryRequest::getTags()const
{
return tags_;
}
void AddAccessControlListEntryRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}

45
slb/src/model/AddAccessControlListEntryResult.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/AddAccessControlListEntryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
AddAccessControlListEntryResult::AddAccessControlListEntryResult() :
ServiceResult()
{}
AddAccessControlListEntryResult::AddAccessControlListEntryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddAccessControlListEntryResult::~AddAccessControlListEntryResult()
{}
void AddAccessControlListEntryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

52
slb/src/model/AddBackendServersResult.cc
View File

@@ -40,28 +40,36 @@ void AddBackendServersResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = value["Weight"].asString();
backendServers_.push_back(backendServersObject);
}
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = value["Weight"].asString();
if(!value["ServerIp"].isNull())
backendServersObject.serverIp = value["ServerIp"].asString();
if(!value["VpcId"].isNull())
backendServersObject.vpcId = value["VpcId"].asString();
if(!value["EniHost"].isNull())
backendServersObject.eniHost = value["EniHost"].asString();
if(!value["Type"].isNull())
backendServersObject.type = value["Type"].asString();
backendServers_.push_back(backendServersObject);
}
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
}
std::string AddBackendServersResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
std::vector<AddBackendServersResult::BackendServer> AddBackendServersResult::getBackendServers()const
{
return backendServers_;
}
std::string AddBackendServersResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
std::vector<AddBackendServersResult::BackendServer> AddBackendServersResult::getBackendServers()const
{
return backendServers_;
}

56
slb/src/model/AddVServerGroupBackendServersResult.cc
View File

@@ -40,30 +40,38 @@ void AddVServerGroupBackendServersResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["Type"].isNull())
backendServersObject.type = value["Type"].asString();
if(!value["ServerIp"].isNull())
backendServersObject.serverIp = value["ServerIp"].asString();
if(!value["EniHost"].isNull())
backendServersObject.eniHost = value["EniHost"].asString();
if(!value["VpcId"].isNull())
backendServersObject.vpcId = value["VpcId"].asString();
backendServers_.push_back(backendServersObject);
}
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
}
std::string AddVServerGroupBackendServersResult::getVServerGroupId()const
{
return vServerGroupId_;
}
std::vector<AddVServerGroupBackendServersResult::BackendServer> AddVServerGroupBackendServersResult::getBackendServers()const
{
return backendServers_;
}
std::string AddVServerGroupBackendServersResult::getVServerGroupId()const
{
return vServerGroupId_;
}
std::vector<AddVServerGroupBackendServersResult::BackendServer> AddVServerGroupBackendServersResult::getBackendServers()const
{
return backendServers_;
}

137
slb/src/model/CreateAccessControlListRequest.cc Normal file
View File

@@ -0,0 +1,137 @@
/*
* 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/slb/model/CreateAccessControlListRequest.h>
using AlibabaCloud::Slb::Model::CreateAccessControlListRequest;
CreateAccessControlListRequest::CreateAccessControlListRequest() :
RpcServiceRequest("slb", "2014-05-15", "CreateAccessControlList")
{}
CreateAccessControlListRequest::~CreateAccessControlListRequest()
{}
std::string CreateAccessControlListRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateAccessControlListRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long CreateAccessControlListRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateAccessControlListRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateAccessControlListRequest::getAclName()const
{
return aclName_;
}
void CreateAccessControlListRequest::setAclName(const std::string& aclName)
{
aclName_ = aclName;
setParameter("AclName", aclName);
}
std::string CreateAccessControlListRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateAccessControlListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateAccessControlListRequest::getRegionId()const
{
return regionId_;
}
void CreateAccessControlListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateAccessControlListRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateAccessControlListRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateAccessControlListRequest::getOwnerId()const
{
return ownerId_;
}
void CreateAccessControlListRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateAccessControlListRequest::getAddressIPVersion()const
{
return addressIPVersion_;
}
void CreateAccessControlListRequest::setAddressIPVersion(const std::string& addressIPVersion)
{
addressIPVersion_ = addressIPVersion;
setParameter("AddressIPVersion", addressIPVersion);
}
std::string CreateAccessControlListRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateAccessControlListRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateAccessControlListRequest::getTags()const
{
return tags_;
}
void CreateAccessControlListRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}

52
slb/src/model/CreateAccessControlListResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/CreateAccessControlListResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
CreateAccessControlListResult::CreateAccessControlListResult() :
ServiceResult()
{}
CreateAccessControlListResult::CreateAccessControlListResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateAccessControlListResult::~CreateAccessControlListResult()
{}
void CreateAccessControlListResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AclId"].isNull())
aclId_ = value["AclId"].asString();
}
std::string CreateAccessControlListResult::getAclId()const
{
return aclId_;
}

148
slb/src/model/CreateDomainExtensionRequest.cc Normal file
View File

@@ -0,0 +1,148 @@
/*
* 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/slb/model/CreateDomainExtensionRequest.h>
using AlibabaCloud::Slb::Model::CreateDomainExtensionRequest;
CreateDomainExtensionRequest::CreateDomainExtensionRequest() :
RpcServiceRequest("slb", "2014-05-15", "CreateDomainExtension")
{}
CreateDomainExtensionRequest::~CreateDomainExtensionRequest()
{}
std::string CreateDomainExtensionRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateDomainExtensionRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long CreateDomainExtensionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDomainExtensionRequest::getListenerPort()const
{
return listenerPort_;
}
void CreateDomainExtensionRequest::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
setParameter("ListenerPort", std::to_string(listenerPort));
}
std::string CreateDomainExtensionRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void CreateDomainExtensionRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string CreateDomainExtensionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDomainExtensionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDomainExtensionRequest::getRegionId()const
{
return regionId_;
}
void CreateDomainExtensionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDomainExtensionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDomainExtensionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateDomainExtensionRequest::getDomain()const
{
return domain_;
}
void CreateDomainExtensionRequest::setDomain(const std::string& domain)
{
domain_ = domain;
setParameter("Domain", domain);
}
long CreateDomainExtensionRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDomainExtensionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDomainExtensionRequest::getServerCertificateId()const
{
return serverCertificateId_;
}
void CreateDomainExtensionRequest::setServerCertificateId(const std::string& serverCertificateId)
{
serverCertificateId_ = serverCertificateId;
setParameter("ServerCertificateId", serverCertificateId);
}
std::string CreateDomainExtensionRequest::getTags()const
{
return tags_;
}
void CreateDomainExtensionRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}

59
slb/src/model/CreateDomainExtensionResult.cc Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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/slb/model/CreateDomainExtensionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
CreateDomainExtensionResult::CreateDomainExtensionResult() :
ServiceResult()
{}
CreateDomainExtensionResult::CreateDomainExtensionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDomainExtensionResult::~CreateDomainExtensionResult()
{}
void CreateDomainExtensionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ListenerPort"].isNull())
listenerPort_ = std::stoi(value["ListenerPort"].asString());
if(!value["DomainExtensionId"].isNull())
domainExtensionId_ = value["DomainExtensionId"].asString();
}
int CreateDomainExtensionResult::getListenerPort()const
{
return listenerPort_;
}
std::string CreateDomainExtensionResult::getDomainExtensionId()const
{
return domainExtensionId_;
}

99
slb/src/model/CreateLoadBalancerHTTPListenerRequest.cc
View File

@@ -58,6 +58,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckTimeout(int healthChec
setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout));
}
std::string CreateLoadBalancerHTTPListenerRequest::getListenerForward()const
{
return listenerForward_;
}
void CreateLoadBalancerHTTPListenerRequest::setListenerForward(const std::string& listenerForward)
{
listenerForward_ = listenerForward;
setParameter("ListenerForward", listenerForward);
}
std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor()const
{
return xForwardedFor_;
@@ -80,6 +91,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckURI(const std::string&
setParameter("HealthCheckURI", healthCheckURI);
}
std::string CreateLoadBalancerHTTPListenerRequest::getDescription()const
{
return description_;
}
void CreateLoadBalancerHTTPListenerRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateLoadBalancerHTTPListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
@@ -102,6 +124,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthyThreshold(int healthyThres
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerHTTPListenerRequest::getAclStatus()const
{
return aclStatus_;
}
void CreateLoadBalancerHTTPListenerRequest::setAclStatus(const std::string& aclStatus)
{
aclStatus_ = aclStatus;
setParameter("AclStatus", aclStatus);
}
std::string CreateLoadBalancerHTTPListenerRequest::getScheduler()const
{
return scheduler_;
@@ -113,6 +146,17 @@ void CreateLoadBalancerHTTPListenerRequest::setScheduler(const std::string& sche
setParameter("Scheduler", scheduler);
}
std::string CreateLoadBalancerHTTPListenerRequest::getAclType()const
{
return aclType_;
}
void CreateLoadBalancerHTTPListenerRequest::setAclType(const std::string& aclType)
{
aclType_ = aclType;
setParameter("AclType", aclType);
}
std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheck()const
{
return healthCheck_;
@@ -124,6 +168,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheck(const std::string& he
setParameter("HealthCheck", healthCheck);
}
int CreateLoadBalancerHTTPListenerRequest::getForwardPort()const
{
return forwardPort_;
}
void CreateLoadBalancerHTTPListenerRequest::setForwardPort(int forwardPort)
{
forwardPort_ = forwardPort;
setParameter("ForwardPort", std::to_string(forwardPort));
}
int CreateLoadBalancerHTTPListenerRequest::getMaxConnection()const
{
return maxConnection_;
@@ -168,6 +223,17 @@ void CreateLoadBalancerHTTPListenerRequest::setStickySessionType(const std::stri
setParameter("StickySessionType", stickySessionType);
}
std::string CreateLoadBalancerHTTPListenerRequest::getVpcIds()const
{
return vpcIds_;
}
void CreateLoadBalancerHTTPListenerRequest::setVpcIds(const std::string& vpcIds)
{
vpcIds_ = vpcIds;
setParameter("VpcIds", vpcIds);
}
std::string CreateLoadBalancerHTTPListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
@@ -179,6 +245,17 @@ void CreateLoadBalancerHTTPListenerRequest::setVServerGroupId(const std::string&
setParameter("VServerGroupId", vServerGroupId);
}
std::string CreateLoadBalancerHTTPListenerRequest::getAclId()const
{
return aclId_;
}
void CreateLoadBalancerHTTPListenerRequest::setAclId(const std::string& aclId)
{
aclId_ = aclId;
setParameter("AclId", aclId);
}
int CreateLoadBalancerHTTPListenerRequest::getListenerPort()const
{
return listenerPort_;
@@ -245,6 +322,17 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckDomain(const std::stri
setParameter("HealthCheckDomain", healthCheckDomain);
}
int CreateLoadBalancerHTTPListenerRequest::getRequestTimeout()const
{
return requestTimeout_;
}
void CreateLoadBalancerHTTPListenerRequest::setRequestTimeout(int requestTimeout)
{
requestTimeout_ = requestTimeout;
setParameter("RequestTimeout", std::to_string(requestTimeout));
}
std::string CreateLoadBalancerHTTPListenerRequest::getOwnerAccount()const
{
return ownerAccount_;
@@ -289,6 +377,17 @@ void CreateLoadBalancerHTTPListenerRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
int CreateLoadBalancerHTTPListenerRequest::getIdleTimeout()const
{
return idleTimeout_;
}
void CreateLoadBalancerHTTPListenerRequest::setIdleTimeout(int idleTimeout)
{
idleTimeout_ = idleTimeout;
setParameter("IdleTimeout", std::to_string(idleTimeout));
}
std::string CreateLoadBalancerHTTPListenerRequest::getLoadBalancerId()const
{
return loadBalancerId_;

99
slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc
View File

@@ -80,6 +80,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckURI(const std::string
setParameter("HealthCheckURI", healthCheckURI);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getDescription()const
{
return description_;
}
void CreateLoadBalancerHTTPSListenerRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateLoadBalancerHTTPSListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
@@ -102,6 +113,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthyThreshold(int healthyThre
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerHTTPSListenerRequest::getAclStatus()const
{
return aclStatus_;
}
void CreateLoadBalancerHTTPSListenerRequest::setAclStatus(const std::string& aclStatus)
{
aclStatus_ = aclStatus;
setParameter("AclStatus", aclStatus);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getScheduler()const
{
return scheduler_;
@@ -113,6 +135,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setScheduler(const std::string& sch
setParameter("Scheduler", scheduler);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getAclType()const
{
return aclType_;
}
void CreateLoadBalancerHTTPSListenerRequest::setAclType(const std::string& aclType)
{
aclType_ = aclType;
setParameter("AclType", aclType);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheck()const
{
return healthCheck_;
@@ -135,6 +168,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setMaxConnection(int maxConnection)
setParameter("MaxConnection", std::to_string(maxConnection));
}
std::string CreateLoadBalancerHTTPSListenerRequest::getEnableHttp2()const
{
return enableHttp2_;
}
void CreateLoadBalancerHTTPSListenerRequest::setEnableHttp2(const std::string& enableHttp2)
{
enableHttp2_ = enableHttp2;
setParameter("EnableHttp2", enableHttp2);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getRegionId()const
{
return regionId_;
@@ -168,6 +212,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setStickySessionType(const std::str
setParameter("StickySessionType", stickySessionType);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getVpcIds()const
{
return vpcIds_;
}
void CreateLoadBalancerHTTPSListenerRequest::setVpcIds(const std::string& vpcIds)
{
vpcIds_ = vpcIds;
setParameter("VpcIds", vpcIds);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
@@ -179,6 +234,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setVServerGroupId(const std::string
setParameter("VServerGroupId", vServerGroupId);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getAclId()const
{
return aclId_;
}
void CreateLoadBalancerHTTPSListenerRequest::setAclId(const std::string& aclId)
{
aclId_ = aclId;
setParameter("AclId", aclId);
}
int CreateLoadBalancerHTTPSListenerRequest::getListenerPort()const
{
return listenerPort_;
@@ -245,6 +311,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckDomain(const std::str
setParameter("HealthCheckDomain", healthCheckDomain);
}
int CreateLoadBalancerHTTPSListenerRequest::getRequestTimeout()const
{
return requestTimeout_;
}
void CreateLoadBalancerHTTPSListenerRequest::setRequestTimeout(int requestTimeout)
{
requestTimeout_ = requestTimeout;
setParameter("RequestTimeout", std::to_string(requestTimeout));
}
std::string CreateLoadBalancerHTTPSListenerRequest::getOwnerAccount()const
{
return ownerAccount_;
@@ -267,6 +344,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setGzip(const std::string& gzip)
setParameter("Gzip", gzip);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getTLSCipherPolicy()const
{
return tLSCipherPolicy_;
}
void CreateLoadBalancerHTTPSListenerRequest::setTLSCipherPolicy(const std::string& tLSCipherPolicy)
{
tLSCipherPolicy_ = tLSCipherPolicy;
setParameter("TLSCipherPolicy", tLSCipherPolicy);
}
long CreateLoadBalancerHTTPSListenerRequest::getOwnerId()const
{
return ownerId_;
@@ -311,6 +399,17 @@ void CreateLoadBalancerHTTPSListenerRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
int CreateLoadBalancerHTTPSListenerRequest::getIdleTimeout()const
{
return idleTimeout_;
}
void CreateLoadBalancerHTTPSListenerRequest::setIdleTimeout(int idleTimeout)
{
idleTimeout_ = idleTimeout;
setParameter("IdleTimeout", std::to_string(idleTimeout));
}
std::string CreateLoadBalancerHTTPSListenerRequest::getLoadBalancerId()const
{
return loadBalancerId_;

241
slb/src/model/CreateLoadBalancerRequest.cc
View File

@@ -36,17 +36,6 @@ void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_i
setParameter("Access_key_id", access_key_id);
}
std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
}
void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec)
{
loadBalancerSpec_ = loadBalancerSpec;
setParameter("LoadBalancerSpec", loadBalancerSpec);
}
long CreateLoadBalancerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
@@ -58,39 +47,6 @@ void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
}
void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
{
autoPay_ = autoPay;
setParameter("AutoPay", std::to_string(autoPay));
}
std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateLoadBalancerRequest::getBandwidth()const
{
return bandwidth_;
}
void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
setParameter("Bandwidth", std::to_string(bandwidth));
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
@@ -102,26 +58,15 @@ void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getOwnerAccount()const
std::string CreateLoadBalancerRequest::getAddressIPVersion()const
{
return ownerAccount_;
return addressIPVersion_;
}
void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
void CreateLoadBalancerRequest::setAddressIPVersion(const std::string& addressIPVersion)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateLoadBalancerRequest::getOwnerId()const
{
return ownerId_;
}
void CreateLoadBalancerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
addressIPVersion_ = addressIPVersion;
setParameter("AddressIPVersion", addressIPVersion);
}
std::string CreateLoadBalancerRequest::getMasterZoneId()const
@@ -135,28 +80,6 @@ void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
setParameter("MasterZoneId", masterZoneId);
}
std::string CreateLoadBalancerRequest::getTags()const
{
return tags_;
}
void CreateLoadBalancerRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string CreateLoadBalancerRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
int CreateLoadBalancerRequest::getDuration()const
{
return duration_;
@@ -190,17 +113,6 @@ void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalan
setParameter("LoadBalancerName", loadBalancerName);
}
std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
{
return enableVpcVipFlow_;
}
void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow)
{
enableVpcVipFlow_ = enableVpcVipFlow;
setParameter("EnableVpcVipFlow", enableVpcVipFlow);
}
std::string CreateLoadBalancerRequest::getRegionId()const
{
return regionId_;
@@ -212,28 +124,6 @@ void CreateLoadBalancerRequest::setRegionId(const std::string& regionId)
setParameter("RegionId", regionId);
}
std::string CreateLoadBalancerRequest::getInternetChargeType()const
{
return internetChargeType_;
}
void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType)
{
internetChargeType_ = internetChargeType;
setParameter("InternetChargeType", internetChargeType);
}
std::string CreateLoadBalancerRequest::getVpcId()const
{
return vpcId_;
}
void CreateLoadBalancerRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setParameter("VpcId", vpcId);
}
std::string CreateLoadBalancerRequest::getAddressType()const
{
return addressType_;
@@ -256,6 +146,127 @@ void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
setParameter("SlaveZoneId", slaveZoneId);
}
std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
}
void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec)
{
loadBalancerSpec_ = loadBalancerSpec;
setParameter("LoadBalancerSpec", loadBalancerSpec);
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
}
void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
{
autoPay_ = autoPay;
setParameter("AutoPay", std::to_string(autoPay));
}
std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateLoadBalancerRequest::getBandwidth()const
{
return bandwidth_;
}
void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
setParameter("Bandwidth", std::to_string(bandwidth));
}
std::string CreateLoadBalancerRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateLoadBalancerRequest::getOwnerId()const
{
return ownerId_;
}
void CreateLoadBalancerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateLoadBalancerRequest::getTags()const
{
return tags_;
}
void CreateLoadBalancerRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string CreateLoadBalancerRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
{
return enableVpcVipFlow_;
}
void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow)
{
enableVpcVipFlow_ = enableVpcVipFlow;
setParameter("EnableVpcVipFlow", enableVpcVipFlow);
}
std::string CreateLoadBalancerRequest::getInternetChargeType()const
{
return internetChargeType_;
}
void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType)
{
internetChargeType_ = internetChargeType;
setParameter("InternetChargeType", internetChargeType);
}
std::string CreateLoadBalancerRequest::getVpcId()const
{
return vpcId_;
}
void CreateLoadBalancerRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setParameter("VpcId", vpcId);
}
std::string CreateLoadBalancerRequest::getPayType()const
{
return payType_;

119
slb/src/model/CreateLoadBalancerResult.cc
View File

@@ -40,62 +40,69 @@ void CreateLoadBalancerResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["ResourceGroupId"].isNull())
resourceGroupId_ = value["ResourceGroupId"].asString();
if(!value["Address"].isNull())
address_ = value["Address"].asString();
if(!value["LoadBalancerName"].isNull())
loadBalancerName_ = value["LoadBalancerName"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["VSwitchId"].isNull())
vSwitchId_ = value["VSwitchId"].asString();
if(!value["NetworkType"].isNull())
networkType_ = value["NetworkType"].asString();
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["ResourceGroupId"].isNull())
resourceGroupId_ = value["ResourceGroupId"].asString();
if(!value["Address"].isNull())
address_ = value["Address"].asString();
if(!value["LoadBalancerName"].isNull())
loadBalancerName_ = value["LoadBalancerName"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["VSwitchId"].isNull())
vSwitchId_ = value["VSwitchId"].asString();
if(!value["NetworkType"].isNull())
networkType_ = value["NetworkType"].asString();
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
if(!value["AddressIPVersion"].isNull())
addressIPVersion_ = value["AddressIPVersion"].asString();
}
std::string CreateLoadBalancerResult::getLoadBalancerName()const
{
return loadBalancerName_;
}
std::string CreateLoadBalancerResult::getResourceGroupId()const
{
return resourceGroupId_;
}
std::string CreateLoadBalancerResult::getAddress()const
{
return address_;
}
std::string CreateLoadBalancerResult::getVpcId()const
{
return vpcId_;
}
std::string CreateLoadBalancerResult::getNetworkType()const
{
return networkType_;
}
std::string CreateLoadBalancerResult::getVSwitchId()const
{
return vSwitchId_;
}
std::string CreateLoadBalancerResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
long CreateLoadBalancerResult::getOrderId()const
{
return orderId_;
}
std::string CreateLoadBalancerResult::getLoadBalancerName()const
{
return loadBalancerName_;
}
std::string CreateLoadBalancerResult::getResourceGroupId()const
{
return resourceGroupId_;
}
std::string CreateLoadBalancerResult::getAddress()const
{
return address_;
}
std::string CreateLoadBalancerResult::getVpcId()const
{
return vpcId_;
}
std::string CreateLoadBalancerResult::getNetworkType()const
{
return networkType_;
}
std::string CreateLoadBalancerResult::getVSwitchId()const
{
return vSwitchId_;
}
std::string CreateLoadBalancerResult::getAddressIPVersion()const
{
return addressIPVersion_;
}
std::string CreateLoadBalancerResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
long CreateLoadBalancerResult::getOrderId()const
{
return orderId_;
}

55
slb/src/model/CreateLoadBalancerTCPListenerRequest.cc
View File

@@ -69,6 +69,17 @@ void CreateLoadBalancerTCPListenerRequest::setHealthCheckURI(const std::string&
setParameter("HealthCheckURI", healthCheckURI);
}
std::string CreateLoadBalancerTCPListenerRequest::getDescription()const
{
return description_;
}
void CreateLoadBalancerTCPListenerRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateLoadBalancerTCPListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
@@ -91,6 +102,17 @@ void CreateLoadBalancerTCPListenerRequest::setHealthyThreshold(int healthyThresh
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerTCPListenerRequest::getAclStatus()const
{
return aclStatus_;
}
void CreateLoadBalancerTCPListenerRequest::setAclStatus(const std::string& aclStatus)
{
aclStatus_ = aclStatus;
setParameter("AclStatus", aclStatus);
}
std::string CreateLoadBalancerTCPListenerRequest::getScheduler()const
{
return scheduler_;
@@ -102,6 +124,17 @@ void CreateLoadBalancerTCPListenerRequest::setScheduler(const std::string& sched
setParameter("Scheduler", scheduler);
}
std::string CreateLoadBalancerTCPListenerRequest::getAclType()const
{
return aclType_;
}
void CreateLoadBalancerTCPListenerRequest::setAclType(const std::string& aclType)
{
aclType_ = aclType;
setParameter("AclType", aclType);
}
int CreateLoadBalancerTCPListenerRequest::getEstablishedTimeout()const
{
return establishedTimeout_;
@@ -146,6 +179,17 @@ void CreateLoadBalancerTCPListenerRequest::setPersistenceTimeout(int persistence
setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
}
std::string CreateLoadBalancerTCPListenerRequest::getVpcIds()const
{
return vpcIds_;
}
void CreateLoadBalancerTCPListenerRequest::setVpcIds(const std::string& vpcIds)
{
vpcIds_ = vpcIds;
setParameter("VpcIds", vpcIds);
}
std::string CreateLoadBalancerTCPListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
@@ -157,6 +201,17 @@ void CreateLoadBalancerTCPListenerRequest::setVServerGroupId(const std::string&
setParameter("VServerGroupId", vServerGroupId);
}
std::string CreateLoadBalancerTCPListenerRequest::getAclId()const
{
return aclId_;
}
void CreateLoadBalancerTCPListenerRequest::setAclId(const std::string& aclId)
{
aclId_ = aclId;
setParameter("AclId", aclId);
}
int CreateLoadBalancerTCPListenerRequest::getListenerPort()const
{
return listenerPort_;

209
slb/src/model/CreateLoadBalancerUDPListenerRequest.cc
View File

@@ -36,17 +36,6 @@ void CreateLoadBalancerUDPListenerRequest::setAccess_key_id(const std::string& a
setParameter("Access_key_id", access_key_id);
}
std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
}
void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
setParameter("VServerGroupId", vServerGroupId);
}
int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectTimeout()const
{
return healthCheckConnectTimeout_;
@@ -69,6 +58,138 @@ void CreateLoadBalancerUDPListenerRequest::setResourceOwnerId(long resourceOwner
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateLoadBalancerUDPListenerRequest::getDescription()const
{
return description_;
}
void CreateLoadBalancerUDPListenerRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
}
int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const
{
return healthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerUDPListenerRequest::getAclStatus()const
{
return aclStatus_;
}
void CreateLoadBalancerUDPListenerRequest::setAclStatus(const std::string& aclStatus)
{
aclStatus_ = aclStatus;
setParameter("AclStatus", aclStatus);
}
std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const
{
return scheduler_;
}
void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
setParameter("Scheduler", scheduler);
}
std::string CreateLoadBalancerUDPListenerRequest::getAclType()const
{
return aclType_;
}
void CreateLoadBalancerUDPListenerRequest::setAclType(const std::string& aclType)
{
aclType_ = aclType;
setParameter("AclType", aclType);
}
int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const
{
return maxConnection_;
}
void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
setParameter("MaxConnection", std::to_string(maxConnection));
}
std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
{
return persistenceTimeout_;
}
void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout)
{
persistenceTimeout_ = persistenceTimeout;
setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
}
std::string CreateLoadBalancerUDPListenerRequest::getVpcIds()const
{
return vpcIds_;
}
void CreateLoadBalancerUDPListenerRequest::setVpcIds(const std::string& vpcIds)
{
vpcIds_ = vpcIds;
setParameter("VpcIds", vpcIds);
}
std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
}
void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
setParameter("VServerGroupId", vServerGroupId);
}
std::string CreateLoadBalancerUDPListenerRequest::getAclId()const
{
return aclId_;
}
void CreateLoadBalancerUDPListenerRequest::setAclId(const std::string& aclId)
{
aclId_ = aclId;
setParameter("AclId", aclId);
}
int CreateLoadBalancerUDPListenerRequest::getListenerPort()const
{
return listenerPort_;
@@ -113,17 +234,6 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerAccount(const std::string& ow
setParameter("OwnerAccount", ownerAccount);
}
int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
}
long CreateLoadBalancerUDPListenerRequest::getOwnerId()const
{
return ownerId_;
@@ -135,17 +245,6 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const
{
return healthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerUDPListenerRequest::getTags()const
{
return tags_;
@@ -157,17 +256,6 @@ void CreateLoadBalancerUDPListenerRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const
{
return scheduler_;
}
void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
setParameter("Scheduler", scheduler);
}
std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId()const
{
return loadBalancerId_;
@@ -179,17 +267,6 @@ void CreateLoadBalancerUDPListenerRequest::setLoadBalancerId(const std::string&
setParameter("LoadBalancerId", loadBalancerId);
}
int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const
{
return maxConnection_;
}
void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
setParameter("MaxConnection", std::to_string(maxConnection));
}
std::string CreateLoadBalancerUDPListenerRequest::getMasterSlaveServerGroupId()const
{
return masterSlaveServerGroupId_;
@@ -212,17 +289,6 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckReq(const std::string&
setParameter("HealthCheckReq", healthCheckReq);
}
std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateLoadBalancerUDPListenerRequest::getBackendServerPort()const
{
return backendServerPort_;
@@ -245,17 +311,6 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckInterval(int healthChec
setParameter("HealthCheckInterval", std::to_string(healthCheckInterval));
}
int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
{
return persistenceTimeout_;
}
void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout)
{
persistenceTimeout_ = persistenceTimeout;
setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
}
std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckExp()const
{
return healthCheckExp_;

60
slb/src/model/CreateMasterSlaveServerGroupResult.cc
View File

@@ -40,32 +40,40 @@ void CreateMasterSlaveServerGroupResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto value : allMasterSlaveBackendServers)
{
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!value["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["ServerType"].isNull())
masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto value : allMasterSlaveBackendServers)
{
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!value["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["ServerType"].isNull())
masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
if(!value["Type"].isNull())
masterSlaveBackendServersObject.type = value["Type"].asString();
if(!value["ServerIp"].isNull())
masterSlaveBackendServersObject.serverIp = value["ServerIp"].asString();
if(!value["EniHost"].isNull())
masterSlaveBackendServersObject.eniHost = value["EniHost"].asString();
if(!value["VpcId"].isNull())
masterSlaveBackendServersObject.vpcId = value["VpcId"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
}
std::string CreateMasterSlaveServerGroupResult::getMasterSlaveServerGroupId()const
{
return masterSlaveServerGroupId_;
}
std::vector<CreateMasterSlaveServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveServerGroupResult::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}
std::string CreateMasterSlaveServerGroupResult::getMasterSlaveServerGroupId()const
{
return masterSlaveServerGroupId_;
}
std::vector<CreateMasterSlaveServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveServerGroupResult::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}

Some files were not shown because too many files have changed in this diff Show More