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

Support SLB latest OpenAPIs.

Browse Source
This commit is contained in:
sdk-team
2020-12-22 09:00:08 +00:00
parent 55c2e91e9f
commit 505b8e2062
71 changed files with 2163 additions and 1993 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-12-22 Version: patch
- Support SLB latest OpenAPIs.
2020-12-22 Version: patch
- Release InterpolateVideoFrame ToneSdrVideo ConvertHdrVideo.

44
slb/CMakeLists.txt
View File

@@ -47,10 +47,10 @@ set(slb_public_header_model
include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h
include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h
include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h
include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h
include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h
include/alibabacloud/slb/model/CreateRulesRequest.h
include/alibabacloud/slb/model/CreateRulesResult.h
include/alibabacloud/slb/model/CreateTLSCipherPolicyRequest.h
include/alibabacloud/slb/model/CreateTLSCipherPolicyResult.h
include/alibabacloud/slb/model/CreateVServerGroupRequest.h
include/alibabacloud/slb/model/CreateVServerGroupResult.h
include/alibabacloud/slb/model/DeleteAccessControlListRequest.h
@@ -65,12 +65,12 @@ set(slb_public_header_model
include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h
include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h
include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h
include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h
include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h
include/alibabacloud/slb/model/DeleteRulesRequest.h
include/alibabacloud/slb/model/DeleteRulesResult.h
include/alibabacloud/slb/model/DeleteServerCertificateRequest.h
include/alibabacloud/slb/model/DeleteServerCertificateResult.h
include/alibabacloud/slb/model/DeleteTLSCipherPolicyRequest.h
include/alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h
include/alibabacloud/slb/model/DeleteVServerGroupRequest.h
include/alibabacloud/slb/model/DeleteVServerGroupResult.h
include/alibabacloud/slb/model/DescribeAccessControlListAttributeRequest.h
@@ -95,8 +95,6 @@ set(slb_public_header_model
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerListenersExRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerListenersExResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h
@@ -107,10 +105,6 @@ set(slb_public_header_model
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h
include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h
include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h
include/alibabacloud/slb/model/DescribeRegionsRequest.h
include/alibabacloud/slb/model/DescribeRegionsResult.h
include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h
@@ -127,6 +121,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/DescribeVServerGroupsResult.h
include/alibabacloud/slb/model/DescribeZonesRequest.h
include/alibabacloud/slb/model/DescribeZonesResult.h
include/alibabacloud/slb/model/ListTLSCipherPoliciesRequest.h
include/alibabacloud/slb/model/ListTLSCipherPoliciesResult.h
include/alibabacloud/slb/model/ListTagResourcesRequest.h
include/alibabacloud/slb/model/ListTagResourcesResult.h
include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h
@@ -163,8 +159,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h
include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExRequest.h
include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h
include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionRequest.h
include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h
include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h
include/alibabacloud/slb/model/SetLoadBalancerNameResult.h
include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h
@@ -177,6 +173,8 @@ set(slb_public_header_model
include/alibabacloud/slb/model/SetRuleResult.h
include/alibabacloud/slb/model/SetServerCertificateNameRequest.h
include/alibabacloud/slb/model/SetServerCertificateNameResult.h
include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeRequest.h
include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeResult.h
include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h
include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h
include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h
@@ -220,10 +218,10 @@ set(slb_src
src/model/CreateLoadBalancerUDPListenerResult.cc
src/model/CreateMasterSlaveServerGroupRequest.cc
src/model/CreateMasterSlaveServerGroupResult.cc
src/model/CreateMasterSlaveVServerGroupRequest.cc
src/model/CreateMasterSlaveVServerGroupResult.cc
src/model/CreateRulesRequest.cc
src/model/CreateRulesResult.cc
src/model/CreateTLSCipherPolicyRequest.cc
src/model/CreateTLSCipherPolicyResult.cc
src/model/CreateVServerGroupRequest.cc
src/model/CreateVServerGroupResult.cc
src/model/DeleteAccessControlListRequest.cc
@@ -238,12 +236,12 @@ set(slb_src
src/model/DeleteLoadBalancerListenerResult.cc
src/model/DeleteMasterSlaveServerGroupRequest.cc
src/model/DeleteMasterSlaveServerGroupResult.cc
src/model/DeleteMasterSlaveVServerGroupRequest.cc
src/model/DeleteMasterSlaveVServerGroupResult.cc
src/model/DeleteRulesRequest.cc
src/model/DeleteRulesResult.cc
src/model/DeleteServerCertificateRequest.cc
src/model/DeleteServerCertificateResult.cc
src/model/DeleteTLSCipherPolicyRequest.cc
src/model/DeleteTLSCipherPolicyResult.cc
src/model/DeleteVServerGroupRequest.cc
src/model/DeleteVServerGroupResult.cc
src/model/DescribeAccessControlListAttributeRequest.cc
@@ -268,8 +266,6 @@ set(slb_src
src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc
src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc
src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
src/model/DescribeLoadBalancerListenersExRequest.cc
src/model/DescribeLoadBalancerListenersExResult.cc
src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc
src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc
src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc
@@ -280,10 +276,6 @@ set(slb_src
src/model/DescribeMasterSlaveServerGroupAttributeResult.cc
src/model/DescribeMasterSlaveServerGroupsRequest.cc
src/model/DescribeMasterSlaveServerGroupsResult.cc
src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc
src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc
src/model/DescribeMasterSlaveVServerGroupsRequest.cc
src/model/DescribeMasterSlaveVServerGroupsResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DescribeRuleAttributeRequest.cc
@@ -300,6 +292,8 @@ set(slb_src
src/model/DescribeVServerGroupsResult.cc
src/model/DescribeZonesRequest.cc
src/model/DescribeZonesResult.cc
src/model/ListTLSCipherPoliciesRequest.cc
src/model/ListTLSCipherPoliciesResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ModifyLoadBalancerInstanceSpecRequest.cc
@@ -336,8 +330,8 @@ set(slb_src
src/model/SetLoadBalancerHTTPListenerAttributeResult.cc
src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc
src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc
src/model/SetLoadBalancerListenerAttributeExRequest.cc
src/model/SetLoadBalancerListenerAttributeExResult.cc
src/model/SetLoadBalancerModificationProtectionRequest.cc
src/model/SetLoadBalancerModificationProtectionResult.cc
src/model/SetLoadBalancerNameRequest.cc
src/model/SetLoadBalancerNameResult.cc
src/model/SetLoadBalancerStatusRequest.cc
@@ -350,6 +344,8 @@ set(slb_src
src/model/SetRuleResult.cc
src/model/SetServerCertificateNameRequest.cc
src/model/SetServerCertificateNameResult.cc
src/model/SetTLSCipherPolicyAttributeRequest.cc
src/model/SetTLSCipherPolicyAttributeResult.cc
src/model/SetVServerGroupAttributeRequest.cc
src/model/SetVServerGroupAttributeResult.cc
src/model/StartLoadBalancerListenerRequest.cc

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

@@ -48,10 +48,10 @@
#include "model/CreateLoadBalancerUDPListenerResult.h"
#include "model/CreateMasterSlaveServerGroupRequest.h"
#include "model/CreateMasterSlaveServerGroupResult.h"
#include "model/CreateMasterSlaveVServerGroupRequest.h"
#include "model/CreateMasterSlaveVServerGroupResult.h"
#include "model/CreateRulesRequest.h"
#include "model/CreateRulesResult.h"
#include "model/CreateTLSCipherPolicyRequest.h"
#include "model/CreateTLSCipherPolicyResult.h"
#include "model/CreateVServerGroupRequest.h"
#include "model/CreateVServerGroupResult.h"
#include "model/DeleteAccessControlListRequest.h"
@@ -66,12 +66,12 @@
#include "model/DeleteLoadBalancerListenerResult.h"
#include "model/DeleteMasterSlaveServerGroupRequest.h"
#include "model/DeleteMasterSlaveServerGroupResult.h"
#include "model/DeleteMasterSlaveVServerGroupRequest.h"
#include "model/DeleteMasterSlaveVServerGroupResult.h"
#include "model/DeleteRulesRequest.h"
#include "model/DeleteRulesResult.h"
#include "model/DeleteServerCertificateRequest.h"
#include "model/DeleteServerCertificateResult.h"
#include "model/DeleteTLSCipherPolicyRequest.h"
#include "model/DeleteTLSCipherPolicyResult.h"
#include "model/DeleteVServerGroupRequest.h"
#include "model/DeleteVServerGroupResult.h"
#include "model/DescribeAccessControlListAttributeRequest.h"
@@ -96,8 +96,6 @@
#include "model/DescribeLoadBalancerHTTPListenerAttributeResult.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/DescribeLoadBalancerListenersExRequest.h"
#include "model/DescribeLoadBalancerListenersExResult.h"
#include "model/DescribeLoadBalancerTCPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerTCPListenerAttributeResult.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeRequest.h"
@@ -108,10 +106,6 @@
#include "model/DescribeMasterSlaveServerGroupAttributeResult.h"
#include "model/DescribeMasterSlaveServerGroupsRequest.h"
#include "model/DescribeMasterSlaveServerGroupsResult.h"
#include "model/DescribeMasterSlaveVServerGroupAttributeRequest.h"
#include "model/DescribeMasterSlaveVServerGroupAttributeResult.h"
#include "model/DescribeMasterSlaveVServerGroupsRequest.h"
#include "model/DescribeMasterSlaveVServerGroupsResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeRuleAttributeRequest.h"
@@ -128,6 +122,8 @@
#include "model/DescribeVServerGroupsResult.h"
#include "model/DescribeZonesRequest.h"
#include "model/DescribeZonesResult.h"
#include "model/ListTLSCipherPoliciesRequest.h"
#include "model/ListTLSCipherPoliciesResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ModifyLoadBalancerInstanceSpecRequest.h"
@@ -164,8 +160,8 @@
#include "model/SetLoadBalancerHTTPListenerAttributeResult.h"
#include "model/SetLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/SetLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/SetLoadBalancerListenerAttributeExRequest.h"
#include "model/SetLoadBalancerListenerAttributeExResult.h"
#include "model/SetLoadBalancerModificationProtectionRequest.h"
#include "model/SetLoadBalancerModificationProtectionResult.h"
#include "model/SetLoadBalancerNameRequest.h"
#include "model/SetLoadBalancerNameResult.h"
#include "model/SetLoadBalancerStatusRequest.h"
@@ -178,6 +174,8 @@
#include "model/SetRuleResult.h"
#include "model/SetServerCertificateNameRequest.h"
#include "model/SetServerCertificateNameResult.h"
#include "model/SetTLSCipherPolicyAttributeRequest.h"
#include "model/SetTLSCipherPolicyAttributeResult.h"
#include "model/SetVServerGroupAttributeRequest.h"
#include "model/SetVServerGroupAttributeResult.h"
#include "model/StartLoadBalancerListenerRequest.h"
@@ -240,12 +238,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateMasterSlaveServerGroupResult> CreateMasterSlaveServerGroupOutcome;
typedef std::future<CreateMasterSlaveServerGroupOutcome> CreateMasterSlaveServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateMasterSlaveServerGroupRequest&, const CreateMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMasterSlaveServerGroupAsyncHandler;
typedef Outcome<Error, Model::CreateMasterSlaveVServerGroupResult> CreateMasterSlaveVServerGroupOutcome;
typedef std::future<CreateMasterSlaveVServerGroupOutcome> CreateMasterSlaveVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateMasterSlaveVServerGroupRequest&, const CreateMasterSlaveVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMasterSlaveVServerGroupAsyncHandler;
typedef Outcome<Error, Model::CreateRulesResult> CreateRulesOutcome;
typedef std::future<CreateRulesOutcome> CreateRulesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateRulesRequest&, const CreateRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRulesAsyncHandler;
typedef Outcome<Error, Model::CreateTLSCipherPolicyResult> CreateTLSCipherPolicyOutcome;
typedef std::future<CreateTLSCipherPolicyOutcome> CreateTLSCipherPolicyOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateTLSCipherPolicyRequest&, const CreateTLSCipherPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTLSCipherPolicyAsyncHandler;
typedef Outcome<Error, Model::CreateVServerGroupResult> CreateVServerGroupOutcome;
typedef std::future<CreateVServerGroupOutcome> CreateVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateVServerGroupRequest&, const CreateVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVServerGroupAsyncHandler;
@@ -267,15 +265,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteMasterSlaveServerGroupResult> DeleteMasterSlaveServerGroupOutcome;
typedef std::future<DeleteMasterSlaveServerGroupOutcome> DeleteMasterSlaveServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveServerGroupRequest&, const DeleteMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveServerGroupAsyncHandler;
typedef Outcome<Error, Model::DeleteMasterSlaveVServerGroupResult> DeleteMasterSlaveVServerGroupOutcome;
typedef std::future<DeleteMasterSlaveVServerGroupOutcome> DeleteMasterSlaveVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveVServerGroupRequest&, const DeleteMasterSlaveVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveVServerGroupAsyncHandler;
typedef Outcome<Error, Model::DeleteRulesResult> DeleteRulesOutcome;
typedef std::future<DeleteRulesOutcome> DeleteRulesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteRulesRequest&, const DeleteRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRulesAsyncHandler;
typedef Outcome<Error, Model::DeleteServerCertificateResult> DeleteServerCertificateOutcome;
typedef std::future<DeleteServerCertificateOutcome> DeleteServerCertificateOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteServerCertificateRequest&, const DeleteServerCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServerCertificateAsyncHandler;
typedef Outcome<Error, Model::DeleteTLSCipherPolicyResult> DeleteTLSCipherPolicyOutcome;
typedef std::future<DeleteTLSCipherPolicyOutcome> DeleteTLSCipherPolicyOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteTLSCipherPolicyRequest&, const DeleteTLSCipherPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTLSCipherPolicyAsyncHandler;
typedef Outcome<Error, Model::DeleteVServerGroupResult> DeleteVServerGroupOutcome;
typedef std::future<DeleteVServerGroupOutcome> DeleteVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteVServerGroupRequest&, const DeleteVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVServerGroupAsyncHandler;
@@ -312,9 +310,6 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::DescribeLoadBalancerListenersExResult> DescribeLoadBalancerListenersExOutcome;
typedef std::future<DescribeLoadBalancerListenersExOutcome> DescribeLoadBalancerListenersExOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerListenersExRequest&, const DescribeLoadBalancerListenersExOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerListenersExAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerTCPListenerAttributeResult> DescribeLoadBalancerTCPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerTCPListenerAttributeOutcome> DescribeLoadBalancerTCPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerTCPListenerAttributeRequest&, const DescribeLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerTCPListenerAttributeAsyncHandler;
@@ -330,12 +325,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeMasterSlaveServerGroupsResult> DescribeMasterSlaveServerGroupsOutcome;
typedef std::future<DescribeMasterSlaveServerGroupsOutcome> DescribeMasterSlaveServerGroupsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveServerGroupsRequest&, const DescribeMasterSlaveServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveServerGroupsAsyncHandler;
typedef Outcome<Error, Model::DescribeMasterSlaveVServerGroupAttributeResult> DescribeMasterSlaveVServerGroupAttributeOutcome;
typedef std::future<DescribeMasterSlaveVServerGroupAttributeOutcome> DescribeMasterSlaveVServerGroupAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveVServerGroupAttributeRequest&, const DescribeMasterSlaveVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveVServerGroupAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeMasterSlaveVServerGroupsResult> DescribeMasterSlaveVServerGroupsOutcome;
typedef std::future<DescribeMasterSlaveVServerGroupsOutcome> DescribeMasterSlaveVServerGroupsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveVServerGroupsRequest&, const DescribeMasterSlaveVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveVServerGroupsAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
@@ -360,6 +349,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
typedef Outcome<Error, Model::ListTLSCipherPoliciesResult> ListTLSCipherPoliciesOutcome;
typedef std::future<ListTLSCipherPoliciesOutcome> ListTLSCipherPoliciesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ListTLSCipherPoliciesRequest&, const ListTLSCipherPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTLSCipherPoliciesAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
@@ -414,9 +406,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::SetLoadBalancerListenerAttributeExResult> SetLoadBalancerListenerAttributeExOutcome;
typedef std::future<SetLoadBalancerListenerAttributeExOutcome> SetLoadBalancerListenerAttributeExOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerListenerAttributeExRequest&, const SetLoadBalancerListenerAttributeExOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerListenerAttributeExAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerModificationProtectionResult> SetLoadBalancerModificationProtectionOutcome;
typedef std::future<SetLoadBalancerModificationProtectionOutcome> SetLoadBalancerModificationProtectionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerModificationProtectionRequest&, const SetLoadBalancerModificationProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerModificationProtectionAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerNameResult> SetLoadBalancerNameOutcome;
typedef std::future<SetLoadBalancerNameOutcome> SetLoadBalancerNameOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerNameRequest&, const SetLoadBalancerNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerNameAsyncHandler;
@@ -435,6 +427,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetServerCertificateNameResult> SetServerCertificateNameOutcome;
typedef std::future<SetServerCertificateNameOutcome> SetServerCertificateNameOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetServerCertificateNameRequest&, const SetServerCertificateNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetServerCertificateNameAsyncHandler;
typedef Outcome<Error, Model::SetTLSCipherPolicyAttributeResult> SetTLSCipherPolicyAttributeOutcome;
typedef std::future<SetTLSCipherPolicyAttributeOutcome> SetTLSCipherPolicyAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetTLSCipherPolicyAttributeRequest&, const SetTLSCipherPolicyAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetTLSCipherPolicyAttributeAsyncHandler;
typedef Outcome<Error, Model::SetVServerGroupAttributeResult> SetVServerGroupAttributeOutcome;
typedef std::future<SetVServerGroupAttributeOutcome> SetVServerGroupAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetVServerGroupAttributeRequest&, const SetVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetVServerGroupAttributeAsyncHandler;
@@ -500,12 +495,12 @@ namespace AlibabaCloud
CreateMasterSlaveServerGroupOutcome createMasterSlaveServerGroup(const Model::CreateMasterSlaveServerGroupRequest &request)const;
void createMasterSlaveServerGroupAsync(const Model::CreateMasterSlaveServerGroupRequest& request, const CreateMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateMasterSlaveServerGroupOutcomeCallable createMasterSlaveServerGroupCallable(const Model::CreateMasterSlaveServerGroupRequest& request) const;
CreateMasterSlaveVServerGroupOutcome createMasterSlaveVServerGroup(const Model::CreateMasterSlaveVServerGroupRequest &request)const;
void createMasterSlaveVServerGroupAsync(const Model::CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateMasterSlaveVServerGroupOutcomeCallable createMasterSlaveVServerGroupCallable(const Model::CreateMasterSlaveVServerGroupRequest& request) const;
CreateRulesOutcome createRules(const Model::CreateRulesRequest &request)const;
void createRulesAsync(const Model::CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRulesOutcomeCallable createRulesCallable(const Model::CreateRulesRequest& request) const;
CreateTLSCipherPolicyOutcome createTLSCipherPolicy(const Model::CreateTLSCipherPolicyRequest &request)const;
void createTLSCipherPolicyAsync(const Model::CreateTLSCipherPolicyRequest& request, const CreateTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateTLSCipherPolicyOutcomeCallable createTLSCipherPolicyCallable(const Model::CreateTLSCipherPolicyRequest& request) const;
CreateVServerGroupOutcome createVServerGroup(const Model::CreateVServerGroupRequest &request)const;
void createVServerGroupAsync(const Model::CreateVServerGroupRequest& request, const CreateVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVServerGroupOutcomeCallable createVServerGroupCallable(const Model::CreateVServerGroupRequest& request) const;
@@ -527,15 +522,15 @@ namespace AlibabaCloud
DeleteMasterSlaveServerGroupOutcome deleteMasterSlaveServerGroup(const Model::DeleteMasterSlaveServerGroupRequest &request)const;
void deleteMasterSlaveServerGroupAsync(const Model::DeleteMasterSlaveServerGroupRequest& request, const DeleteMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteMasterSlaveServerGroupOutcomeCallable deleteMasterSlaveServerGroupCallable(const Model::DeleteMasterSlaveServerGroupRequest& request) const;
DeleteMasterSlaveVServerGroupOutcome deleteMasterSlaveVServerGroup(const Model::DeleteMasterSlaveVServerGroupRequest &request)const;
void deleteMasterSlaveVServerGroupAsync(const Model::DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteMasterSlaveVServerGroupOutcomeCallable deleteMasterSlaveVServerGroupCallable(const Model::DeleteMasterSlaveVServerGroupRequest& request) const;
DeleteRulesOutcome deleteRules(const Model::DeleteRulesRequest &request)const;
void deleteRulesAsync(const Model::DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteRulesOutcomeCallable deleteRulesCallable(const Model::DeleteRulesRequest& request) const;
DeleteServerCertificateOutcome deleteServerCertificate(const Model::DeleteServerCertificateRequest &request)const;
void deleteServerCertificateAsync(const Model::DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteServerCertificateOutcomeCallable deleteServerCertificateCallable(const Model::DeleteServerCertificateRequest& request) const;
DeleteTLSCipherPolicyOutcome deleteTLSCipherPolicy(const Model::DeleteTLSCipherPolicyRequest &request)const;
void deleteTLSCipherPolicyAsync(const Model::DeleteTLSCipherPolicyRequest& request, const DeleteTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTLSCipherPolicyOutcomeCallable deleteTLSCipherPolicyCallable(const Model::DeleteTLSCipherPolicyRequest& request) const;
DeleteVServerGroupOutcome deleteVServerGroup(const Model::DeleteVServerGroupRequest &request)const;
void deleteVServerGroupAsync(const Model::DeleteVServerGroupRequest& request, const DeleteVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVServerGroupOutcomeCallable deleteVServerGroupCallable(const Model::DeleteVServerGroupRequest& request) const;
@@ -572,9 +567,6 @@ namespace AlibabaCloud
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;
DescribeLoadBalancerListenersExOutcome describeLoadBalancerListenersEx(const Model::DescribeLoadBalancerListenersExRequest &request)const;
void describeLoadBalancerListenersExAsync(const Model::DescribeLoadBalancerListenersExRequest& request, const DescribeLoadBalancerListenersExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerListenersExOutcomeCallable describeLoadBalancerListenersExCallable(const Model::DescribeLoadBalancerListenersExRequest& request) const;
DescribeLoadBalancerTCPListenerAttributeOutcome describeLoadBalancerTCPListenerAttribute(const Model::DescribeLoadBalancerTCPListenerAttributeRequest &request)const;
void describeLoadBalancerTCPListenerAttributeAsync(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request, const DescribeLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerTCPListenerAttributeOutcomeCallable describeLoadBalancerTCPListenerAttributeCallable(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request) const;
@@ -590,12 +582,6 @@ namespace AlibabaCloud
DescribeMasterSlaveServerGroupsOutcome describeMasterSlaveServerGroups(const Model::DescribeMasterSlaveServerGroupsRequest &request)const;
void describeMasterSlaveServerGroupsAsync(const Model::DescribeMasterSlaveServerGroupsRequest& request, const DescribeMasterSlaveServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveServerGroupsOutcomeCallable describeMasterSlaveServerGroupsCallable(const Model::DescribeMasterSlaveServerGroupsRequest& request) const;
DescribeMasterSlaveVServerGroupAttributeOutcome describeMasterSlaveVServerGroupAttribute(const Model::DescribeMasterSlaveVServerGroupAttributeRequest &request)const;
void describeMasterSlaveVServerGroupAttributeAsync(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveVServerGroupAttributeOutcomeCallable describeMasterSlaveVServerGroupAttributeCallable(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request) const;
DescribeMasterSlaveVServerGroupsOutcome describeMasterSlaveVServerGroups(const Model::DescribeMasterSlaveVServerGroupsRequest &request)const;
void describeMasterSlaveVServerGroupsAsync(const Model::DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveVServerGroupsOutcomeCallable describeMasterSlaveVServerGroupsCallable(const Model::DescribeMasterSlaveVServerGroupsRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
@@ -620,6 +606,9 @@ namespace AlibabaCloud
DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
ListTLSCipherPoliciesOutcome listTLSCipherPolicies(const Model::ListTLSCipherPoliciesRequest &request)const;
void listTLSCipherPoliciesAsync(const Model::ListTLSCipherPoliciesRequest& request, const ListTLSCipherPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTLSCipherPoliciesOutcomeCallable listTLSCipherPoliciesCallable(const Model::ListTLSCipherPoliciesRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
@@ -674,9 +663,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;
SetLoadBalancerListenerAttributeExOutcome setLoadBalancerListenerAttributeEx(const Model::SetLoadBalancerListenerAttributeExRequest &request)const;
void setLoadBalancerListenerAttributeExAsync(const Model::SetLoadBalancerListenerAttributeExRequest& request, const SetLoadBalancerListenerAttributeExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerListenerAttributeExOutcomeCallable setLoadBalancerListenerAttributeExCallable(const Model::SetLoadBalancerListenerAttributeExRequest& request) const;
SetLoadBalancerModificationProtectionOutcome setLoadBalancerModificationProtection(const Model::SetLoadBalancerModificationProtectionRequest &request)const;
void setLoadBalancerModificationProtectionAsync(const Model::SetLoadBalancerModificationProtectionRequest& request, const SetLoadBalancerModificationProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerModificationProtectionOutcomeCallable setLoadBalancerModificationProtectionCallable(const Model::SetLoadBalancerModificationProtectionRequest& request) const;
SetLoadBalancerNameOutcome setLoadBalancerName(const Model::SetLoadBalancerNameRequest &request)const;
void setLoadBalancerNameAsync(const Model::SetLoadBalancerNameRequest& request, const SetLoadBalancerNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerNameOutcomeCallable setLoadBalancerNameCallable(const Model::SetLoadBalancerNameRequest& request) const;
@@ -695,6 +684,9 @@ namespace AlibabaCloud
SetServerCertificateNameOutcome setServerCertificateName(const Model::SetServerCertificateNameRequest &request)const;
void setServerCertificateNameAsync(const Model::SetServerCertificateNameRequest& request, const SetServerCertificateNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetServerCertificateNameOutcomeCallable setServerCertificateNameCallable(const Model::SetServerCertificateNameRequest& request) const;
SetTLSCipherPolicyAttributeOutcome setTLSCipherPolicyAttribute(const Model::SetTLSCipherPolicyAttributeRequest &request)const;
void setTLSCipherPolicyAttributeAsync(const Model::SetTLSCipherPolicyAttributeRequest& request, const SetTLSCipherPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetTLSCipherPolicyAttributeOutcomeCallable setTLSCipherPolicyAttributeCallable(const Model::SetTLSCipherPolicyAttributeRequest& request) const;
SetVServerGroupAttributeOutcome setVServerGroupAttribute(const Model::SetVServerGroupAttributeRequest &request)const;
void setVServerGroupAttributeAsync(const Model::SetVServerGroupAttributeRequest& request, const SetVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetVServerGroupAttributeOutcomeCallable setVServerGroupAttributeCallable(const Model::SetVServerGroupAttributeRequest& request) const;

13
slb/include/alibabacloud/slb/model/CreateDomainExtensionRequest.h
View File

@@ -30,6 +30,13 @@ namespace AlibabaCloud
{
class ALIBABACLOUD_SLB_EXPORT CreateDomainExtensionRequest : public RpcServiceRequest
{
public:
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string standardType;
};
public:
CreateDomainExtensionRequest();
@@ -39,6 +46,8 @@ namespace AlibabaCloud
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<ServerCertificate> getServerCertificate()const;
void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getListenerPort()const;
@@ -47,6 +56,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::vector<std::string> getCertificateId()const;
void setCertificateId(const std::vector<std::string>& certificateId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
@@ -61,10 +72,12 @@ namespace AlibabaCloud
private:
std::string access_key_id_;
long resourceOwnerId_;
std::vector<ServerCertificate> serverCertificate_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::vector<std::string> certificateId_;
long ownerId_;
std::string serverCertificateId_;
std::string tags_;

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

@@ -30,6 +30,13 @@ namespace AlibabaCloud
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerRequest : public RpcServiceRequest
{
public:
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string standardType;
};
public:
CreateLoadBalancerHTTPSListenerRequest();
@@ -37,6 +44,8 @@ namespace AlibabaCloud
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<ServerCertificate> getServerCertificate()const;
void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getXForwardedFor()const;
@@ -152,6 +161,7 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::vector<ServerCertificate> serverCertificate_;
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;

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

@@ -35,46 +35,20 @@ namespace AlibabaCloud
CreateLoadBalancerRequest();
~CreateLoadBalancerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
bool getSupportPrivateLink()const;
void setSupportPrivateLink(bool supportPrivateLink);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getCloudType()const;
void setCloudType(const std::string& cloudType);
std::string getAddressIPVersion()const;
void setAddressIPVersion(const std::string& addressIPVersion);
std::string getMasterZoneId()const;
void setMasterZoneId(const std::string& masterZoneId);
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 getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getSlaveZoneId()const;
void setSlaveZoneId(const std::string& slaveZoneId);
std::string getDeleteProtection()const;
void setDeleteProtection(const std::string& deleteProtection);
std::string getLoadBalancerSpec()const;
void setLoadBalancerSpec(const std::string& loadBalancerSpec);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getAddress()const;
void setAddress(const std::string& address);
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;
@@ -85,44 +59,76 @@ namespace AlibabaCloud
void setEnableVpcVipFlow(const std::string& enableVpcVipFlow);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getPricingCycle()const;
void setPricingCycle(const std::string& pricingCycle);
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getModificationProtectionReason()const;
void setModificationProtectionReason(const std::string& modificationProtectionReason);
bool getSupportPrivateLink()const;
void setSupportPrivateLink(bool supportPrivateLink);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getCloudType()const;
void setCloudType(const std::string& cloudType);
int getDuration()const;
void setDuration(int duration);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getDeleteProtection()const;
void setDeleteProtection(const std::string& deleteProtection);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getAddress()const;
void setAddress(const std::string& address);
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);
std::string getModificationProtectionStatus()const;
void setModificationProtectionStatus(const std::string& modificationProtectionStatus);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getPricingCycle()const;
void setPricingCycle(const std::string& pricingCycle);
int getRatio()const;
void setRatio(int ratio);
private:
std::string access_key_id_;
long resourceOwnerId_;
bool supportPrivateLink_;
std::string clientToken_;
std::string cloudType_;
std::string addressIPVersion_;
std::string masterZoneId_;
int duration_;
std::string resourceGroupId_;
std::string loadBalancerName_;
std::string regionId_;
std::string addressType_;
std::string slaveZoneId_;
std::string deleteProtection_;
std::string loadBalancerSpec_;
bool autoPay_;
std::string address_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string vSwitchId_;
std::string enableVpcVipFlow_;
std::string internetChargeType_;
std::string pricingCycle_;
std::string access_key_id_;
std::string modificationProtectionReason_;
bool supportPrivateLink_;
std::string clientToken_;
std::string cloudType_;
int duration_;
std::string regionId_;
std::string addressType_;
std::string deleteProtection_;
bool autoPay_;
std::string address_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
std::string modificationProtectionStatus_;
std::string vpcId_;
std::string payType_;
std::string pricingCycle_;
int ratio_;
};

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

@@ -1,65 +0,0 @@
/*
* 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_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_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 CreateMasterSlaveVServerGroupResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string type;
std::string serverId;
std::string description;
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;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_

27
slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h → slb/include/alibabacloud/slb/model/CreateTLSCipherPolicyRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
#ifndef ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_
#include <string>
#include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupRequest : public RpcServiceRequest
class ALIBABACLOUD_SLB_EXPORT CreateTLSCipherPolicyRequest : public RpcServiceRequest
{
public:
DeleteMasterSlaveVServerGroupRequest();
~DeleteMasterSlaveVServerGroupRequest();
CreateTLSCipherPolicyRequest();
~CreateTLSCipherPolicyRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
@@ -43,30 +43,33 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getMasterSlaveVServerGroupId()const;
void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
std::vector<std::string> getCiphers()const;
void setCiphers(const std::vector<std::string>& ciphers);
std::vector<std::string> getTLSVersions()const;
void setTLSVersions(const std::vector<std::string>& tLSVersions);
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);
std::string getName()const;
void setName(const std::string& name);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string masterSlaveVServerGroupId_;
std::vector<std::string> ciphers_;
std::vector<std::string> tLSVersions_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
#endif // !ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_

16
slb/include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h → slb/include/alibabacloud/slb/model/CreateTLSCipherPolicyResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXRESULT_H_
#ifndef ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_
#include <string>
#include <vector>
@@ -29,21 +29,23 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerListenerAttributeExResult : public ServiceResult
class ALIBABACLOUD_SLB_EXPORT CreateTLSCipherPolicyResult : public ServiceResult
{
public:
SetLoadBalancerListenerAttributeExResult();
explicit SetLoadBalancerListenerAttributeExResult(const std::string &payload);
~SetLoadBalancerListenerAttributeExResult();
CreateTLSCipherPolicyResult();
explicit CreateTLSCipherPolicyResult(const std::string &payload);
~CreateTLSCipherPolicyResult();
std::string getTLSCipherPolicyId()const;
protected:
void parse(const std::string &payload);
private:
std::string tLSCipherPolicyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXRESULT_H_
#endif // !ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_

21
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h → slb/include/alibabacloud/slb/model/DeleteTLSCipherPolicyRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
#ifndef ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_
#include <string>
#include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsRequest : public RpcServiceRequest
class ALIBABACLOUD_SLB_EXPORT DeleteTLSCipherPolicyRequest : public RpcServiceRequest
{
public:
DescribeMasterSlaveVServerGroupsRequest();
~DescribeMasterSlaveVServerGroupsRequest();
DeleteTLSCipherPolicyRequest();
~DeleteTLSCipherPolicyRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
@@ -41,6 +41,8 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTLSCipherPolicyId()const;
void setTLSCipherPolicyId(const std::string& tLSCipherPolicyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
@@ -49,24 +51,19 @@ namespace AlibabaCloud
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 getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string tLSCipherPolicyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
#endif // !ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_

14
slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h → slb/include/alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
#ifndef ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_
#include <string>
#include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupResult : public ServiceResult
class ALIBABACLOUD_SLB_EXPORT DeleteTLSCipherPolicyResult : public ServiceResult
{
public:
DeleteMasterSlaveVServerGroupResult();
explicit DeleteMasterSlaveVServerGroupResult(const std::string &payload);
~DeleteMasterSlaveVServerGroupResult();
DeleteTLSCipherPolicyResult();
explicit DeleteTLSCipherPolicyResult(const std::string &payload);
~DeleteTLSCipherPolicyResult();
protected:
void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
#endif // !ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_

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

@@ -44,7 +44,10 @@ namespace AlibabaCloud
long expireTimeStamp;
std::string cACertificateId;
std::string createTime;
std::string standardType;
std::string cACertificateName;
int encryptionKeyLength;
std::string encryptionAlgorithm;
std::string regionId;
std::string expireTime;
std::vector<CACertificate::Tag> tags;

16
slb/include/alibabacloud/slb/model/DescribeDomainExtensionAttributeResult.h
View File

@@ -32,6 +32,18 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeDomainExtensionAttributeResult : public ServiceResult
{
public:
struct Certificate
{
std::string certificateId;
std::string encryptionAlgorithm;
};
struct ServerCertificate
{
std::string certificateId;
std::string bindingType;
std::string encryptionAlgorithm;
std::string standardType;
};
DescribeDomainExtensionAttributeResult();
@@ -39,6 +51,8 @@ namespace AlibabaCloud
~DescribeDomainExtensionAttributeResult();
std::string getDomainExtensionId()const;
int getListenerPort()const;
std::vector<Certificate> getCertificates()const;
std::vector<ServerCertificate> getServerCertificates()const;
std::string getServerCertificateId()const;
std::string getLoadBalancerId()const;
std::string getDomain()const;
@@ -48,6 +62,8 @@ namespace AlibabaCloud
private:
std::string domainExtensionId_;
int listenerPort_;
std::vector<Certificate> certificates_;
std::vector<ServerCertificate> serverCertificates_;
std::string serverCertificateId_;
std::string loadBalancerId_;
std::string domain_;

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

@@ -34,7 +34,21 @@ namespace AlibabaCloud
public:
struct DomainExtension
{
struct Certificate
{
std::string certificateId;
std::string encryptionAlgorithm;
};
struct ServerCertificate
{
std::string certificateId;
std::string bindingType;
std::string encryptionAlgorithm;
std::string standardType;
};
std::string domainExtensionId;
std::vector<DomainExtension::Certificate> certificates;
std::vector<DomainExtension::ServerCertificate> serverCertificates;
std::string serverCertificateId;
std::string domain;
};

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

@@ -71,10 +71,13 @@ namespace AlibabaCloud
std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const;
std::string getHasReservedInfo()const;
std::string getBusinessStatus()const;
std::string getReservedInfoBandwidth()const;
std::string getModificationProtectionStatus()const;
std::string getLoadBalancerSpec()const;
std::string getNetworkType()const;
int getBandwidth()const;
std::string getModificationProtectionReason()const;
std::string getAssociatedCenId()const;
std::vector<std::string> getListenerPorts()const;
std::string getMasterZoneId()const;
@@ -120,10 +123,13 @@ namespace AlibabaCloud
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string hasReservedInfo_;
std::string businessStatus_;
std::string reservedInfoBandwidth_;
std::string modificationProtectionStatus_;
std::string loadBalancerSpec_;
std::string networkType_;
int bandwidth_;
std::string modificationProtectionReason_;
std::string associatedCenId_;
std::vector<std::string> listenerPorts_;
std::string masterZoneId_;

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

@@ -42,10 +42,31 @@ namespace AlibabaCloud
};
struct DomainExtension
{
struct Certificate
{
std::string certificateId;
std::string encryptionAlgorithm;
};
struct ServerCertificate
{
std::string certificateId;
std::string bindingType;
std::string encryptionAlgorithm;
std::string standardType;
};
std::string domainExtensionId;
std::vector<DomainExtension::ServerCertificate> serverCertificates1;
std::vector<DomainExtension::Certificate> certificates;
std::string serverCertificateId;
std::string domain;
};
struct ServerCertificate2
{
std::string certificateId;
std::string bindingType;
std::string encryptionAlgorithm;
std::string standardType;
};
DescribeLoadBalancerHTTPSListenerAttributeResult();
@@ -66,6 +87,7 @@ namespace AlibabaCloud
int getHealthCheckInterval()const;
std::string getTLSCipherPolicy()const;
std::string getCACertificateId()const;
std::vector<ServerCertificate2> getServerCertificates()const;
std::string getXForwardedFor_ClientCertFingerprintAlias()const;
int getHealthCheckTimeout()const;
std::string getAclStatus()const;
@@ -124,6 +146,7 @@ namespace AlibabaCloud
int healthCheckInterval_;
std::string tLSCipherPolicy_;
std::string cACertificateId_;
std::vector<ServerCertificate2> serverCertificates_;
std::string xForwardedFor_ClientCertFingerprintAlias_;
int healthCheckTimeout_;
std::string aclStatus_;

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

@@ -1,57 +0,0 @@
/*
* 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_DESCRIBELOADBALANCERLISTENERSEXREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXREQUEST_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 DescribeLoadBalancerListenersExRequest : public RpcServiceRequest
{
public:
DescribeLoadBalancerListenersExRequest();
~DescribeLoadBalancerListenersExRequest();
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getProtocol()const;
void setProtocol(const std::string& protocol);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
int listenerPort_;
std::string protocol_;
std::string loadBalancerId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXREQUEST_H_

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

@@ -41,48 +41,26 @@ namespace AlibabaCloud
DescribeLoadBalancersRequest();
~DescribeLoadBalancersRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
bool getSupportPrivateLink()const;
void setSupportPrivateLink(bool supportPrivateLink);
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
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 getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
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::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
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;
@@ -93,38 +71,63 @@ namespace AlibabaCloud
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
bool getSupportPrivateLink()const;
void setSupportPrivateLink(bool supportPrivateLink);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getFuzzy()const;
void setFuzzy(const std::string& fuzzy);
std::string getBusinessStatus()const;
void setBusinessStatus(const std::string& businessStatus);
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 getLoadBalancerStatus()const;
void setLoadBalancerStatus(const std::string& loadBalancerStatus);
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_;
bool supportPrivateLink_;
std::string networkType_;
std::string addressIPVersion_;
std::string masterZoneId_;
int pageNumber_;
std::string resourceGroupId_;
std::string loadBalancerName_;
std::string regionId_;
int pageSize_;
std::string addressType_;
std::string slaveZoneId_;
std::vector<Tag> tag_;
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 access_key_id_;
bool supportPrivateLink_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string addressType_;
std::string fuzzy_;
std::string businessStatus_;
std::string address_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string loadBalancerStatus_;
std::string vpcId_;
std::string payType_;

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

@@ -47,11 +47,14 @@ namespace AlibabaCloud
std::string loadBalancerId;
std::string payType;
std::string slaveZoneId;
std::string businessStatus;
std::string modificationProtectionStatus;
std::string internetChargeType;
std::string regionIdAlias;
std::string loadBalancerName;
std::string vpcId;
std::string networkType;
std::string modificationProtectionReason;
std::string regionId;
std::string addressType;
std::string loadBalancerStatus;

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

@@ -1,67 +0,0 @@
/*
* 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_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_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 DescribeMasterSlaveVServerGroupAttributeResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string type;
std::string serverId;
std::string description;
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;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveVServerGroupName_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_

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

@@ -45,11 +45,14 @@ namespace AlibabaCloud
std::string createTime;
std::vector<std::string> subjectAlternativeNames;
std::string aliCloudCertificateId;
std::string standardType;
std::string regionIdAlias;
std::string aliCloudCertificateName;
int isAliCloudCertificate;
int encryptionKeyLength;
std::string serverCertificateId;
std::string serverCertificateName;
std::string encryptionAlgorithm;
std::string regionId;
std::string expireTime;
std::vector<ServerCertificate::Tag> tags;

33
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h → slb/include/alibabacloud/slb/model/ListTLSCipherPoliciesRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
#ifndef ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESREQUEST_H_
#include <string>
#include <vector>
@@ -28,45 +28,54 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeRequest : public RpcServiceRequest
class ALIBABACLOUD_SLB_EXPORT ListTLSCipherPoliciesRequest : public RpcServiceRequest
{
public:
DescribeMasterSlaveVServerGroupAttributeRequest();
~DescribeMasterSlaveVServerGroupAttributeRequest();
ListTLSCipherPoliciesRequest();
~ListTLSCipherPoliciesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
bool getIncludeListener()const;
void setIncludeListener(bool includeListener);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTLSCipherPolicyId()const;
void setTLSCipherPolicyId(const std::string& tLSCipherPolicyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getMasterSlaveVServerGroupId()const;
void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
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);
std::string getName()const;
void setName(const std::string& name);
int getMaxItems()const;
void setMaxItems(int maxItems);
private:
std::string access_key_id_;
long resourceOwnerId_;
bool includeListener_;
std::string accessKeyId_;
std::string tLSCipherPolicyId_;
std::string regionId_;
std::string masterSlaveVServerGroupId_;
std::string nextToken_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string name_;
int maxItems_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
#endif // !ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESREQUEST_H_

73
slb/include/alibabacloud/slb/model/ListTLSCipherPoliciesResult.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESRESULT_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 ListTLSCipherPoliciesResult : public ServiceResult
{
public:
struct TLSCipherPolicy
{
struct RelateListener
{
int port;
std::string loadBalancerId;
std::string protocol;
};
std::string status;
std::vector<TLSCipherPolicy::RelateListener> relateListeners;
std::vector<std::string> ciphers;
std::string instanceId;
long createTime;
std::vector<std::string> tLSVersions;
std::string name;
};
ListTLSCipherPoliciesResult();
explicit ListTLSCipherPoliciesResult(const std::string &payload);
~ListTLSCipherPoliciesResult();
int getTotalCount()const;
std::string getNextToken()const;
std::vector<TLSCipherPolicy> getTLSCipherPolicies()const;
bool getIsTruncated()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::string nextToken_;
std::vector<TLSCipherPolicy> tLSCipherPolicies_;
bool isTruncated_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESRESULT_H_

13
slb/include/alibabacloud/slb/model/SetDomainExtensionAttributeRequest.h
View File

@@ -30,6 +30,13 @@ namespace AlibabaCloud
{
class ALIBABACLOUD_SLB_EXPORT SetDomainExtensionAttributeRequest : public RpcServiceRequest
{
public:
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string standardType;
};
public:
SetDomainExtensionAttributeRequest();
@@ -39,6 +46,8 @@ namespace AlibabaCloud
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<ServerCertificate> getServerCertificate()const;
void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDomainExtensionId()const;
@@ -47,6 +56,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::vector<std::string> getCertificateId()const;
void setCertificateId(const std::vector<std::string>& certificateId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
@@ -57,10 +68,12 @@ namespace AlibabaCloud
private:
std::string access_key_id_;
long resourceOwnerId_;
std::vector<ServerCertificate> serverCertificate_;
std::string regionId_;
std::string domainExtensionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::vector<std::string> certificateId_;
long ownerId_;
std::string serverCertificateId_;
std::string tags_;

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

@@ -30,6 +30,13 @@ namespace AlibabaCloud
{
class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerHTTPSListenerAttributeRequest : public RpcServiceRequest
{
public:
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string standardType;
};
public:
SetLoadBalancerHTTPSListenerAttributeRequest();
@@ -37,6 +44,8 @@ namespace AlibabaCloud
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<ServerCertificate> getServerCertificate()const;
void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getXForwardedFor()const;
@@ -150,6 +159,7 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::vector<ServerCertificate> serverCertificate_;
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;

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

@@ -1,66 +0,0 @@
/*
* 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_SETLOADBALANCERLISTENERATTRIBUTEEXREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXREQUEST_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 SetLoadBalancerListenerAttributeExRequest : public RpcServiceRequest
{
public:
struct KvAttribute
{
std::string value;
std::string key;
};
public:
SetLoadBalancerListenerAttributeExRequest();
~SetLoadBalancerListenerAttributeExRequest();
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::vector<KvAttribute> getKvAttribute()const;
void setKvAttribute(const std::vector<KvAttribute>& kvAttribute);
std::string getProtocol()const;
void setProtocol(const std::string& protocol);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
int listenerPort_;
std::vector<KvAttribute> kvAttribute_;
std::string protocol_;
std::string loadBalancerId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXREQUEST_H_

69
slb/include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionRequest.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_SETLOADBALANCERMODIFICATIONPROTECTIONREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONREQUEST_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 SetLoadBalancerModificationProtectionRequest : public RpcServiceRequest
{
public:
SetLoadBalancerModificationProtectionRequest();
~SetLoadBalancerModificationProtectionRequest();
std::string getModificationProtectionReason()const;
void setModificationProtectionReason(const std::string& modificationProtectionReason);
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 getModificationProtectionStatus()const;
void setModificationProtectionStatus(const std::string& modificationProtectionStatus);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
private:
std::string modificationProtectionReason_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string modificationProtectionStatus_;
std::string ownerAccount_;
long ownerId_;
std::string loadBalancerId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONREQUEST_H_

21
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h → slb/include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONRESULT_H_
#include <string>
#include <vector>
@@ -29,28 +29,21 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsResult : public ServiceResult
class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerModificationProtectionResult : public ServiceResult
{
public:
struct MasterSlaveVServerGroup
{
std::string masterSlaveVServerGroupId;
std::string masterSlaveVServerGroupName;
};
DescribeMasterSlaveVServerGroupsResult();
explicit DescribeMasterSlaveVServerGroupsResult(const std::string &payload);
~DescribeMasterSlaveVServerGroupsResult();
std::vector<MasterSlaveVServerGroup> getMasterSlaveVServerGroups()const;
SetLoadBalancerModificationProtectionResult();
explicit SetLoadBalancerModificationProtectionResult(const std::string &payload);
~SetLoadBalancerModificationProtectionResult();
protected:
void parse(const std::string &payload);
private:
std::vector<MasterSlaveVServerGroup> masterSlaveVServerGroups_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONRESULT_H_

36
slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h → slb/include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
#ifndef ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupRequest : public RpcServiceRequest
class ALIBABACLOUD_SLB_EXPORT SetTLSCipherPolicyAttributeRequest : public RpcServiceRequest
{
public:
CreateMasterSlaveVServerGroupRequest();
~CreateMasterSlaveVServerGroupRequest();
SetTLSCipherPolicyAttributeRequest();
~SetTLSCipherPolicyAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
@@ -41,38 +41,38 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers);
std::string getTLSCipherPolicyId()const;
void setTLSCipherPolicyId(const std::string& tLSCipherPolicyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::vector<std::string> getCiphers()const;
void setCiphers(const std::vector<std::string>& ciphers);
std::vector<std::string> getTLSVersions()const;
void setTLSVersions(const std::vector<std::string>& tLSVersions);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getMasterSlaveVServerGroupName()const;
void setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getName()const;
void setName(const std::string& name);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string masterSlaveBackendServers_;
std::string tLSCipherPolicyId_;
std::string regionId_;
std::vector<std::string> ciphers_;
std::vector<std::string> tLSVersions_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string masterSlaveVServerGroupName_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
#endif // !ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTEREQUEST_H_

26
slb/include/alibabacloud/slb/model/DescribeLoadBalancerListenersExResult.h → slb/include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXRESULT_H_
#ifndef ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTERESULT_H_
#include <string>
#include <vector>
@@ -29,31 +29,23 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerListenersExResult : public ServiceResult
class ALIBABACLOUD_SLB_EXPORT SetTLSCipherPolicyAttributeResult : public ServiceResult
{
public:
struct ListenerAttributeExResponseModel
{
int listenerPort;
std::string protocol;
std::string recordCustomizedHeaders;
};
DescribeLoadBalancerListenersExResult();
explicit DescribeLoadBalancerListenersExResult(const std::string &payload);
~DescribeLoadBalancerListenersExResult();
std::string getLoadBalancerId()const;
std::vector<ListenerAttributeExResponseModel> getListenerExtendedAttributes()const;
SetTLSCipherPolicyAttributeResult();
explicit SetTLSCipherPolicyAttributeResult(const std::string &payload);
~SetTLSCipherPolicyAttributeResult();
std::string getTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerId_;
std::vector<ListenerAttributeExResponseModel> listenerExtendedAttributes_;
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXRESULT_H_
#endif // !ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTERESULT_H_

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

@@ -51,6 +51,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getStandardType()const;
void setStandardType(const std::string& standardType);
long getOwnerId()const;
void setOwnerId(long ownerId);
@@ -63,6 +65,7 @@ namespace AlibabaCloud
std::string cACertificate_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string standardType_;
long ownerId_;
};

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

@@ -55,6 +55,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getStandardType()const;
void setStandardType(const std::string& standardType);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
@@ -75,6 +77,7 @@ namespace AlibabaCloud
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string standardType_;
long ownerId_;
std::string tags_;
std::string aliCloudCertificateRegionId_;

342
slb/src/SlbClient.cc
View File

@@ -519,42 +519,6 @@ SlbClient::CreateMasterSlaveServerGroupOutcomeCallable SlbClient::createMasterSl
return task->get_future();
}
SlbClient::CreateMasterSlaveVServerGroupOutcome SlbClient::createMasterSlaveVServerGroup(const CreateMasterSlaveVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateMasterSlaveVServerGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateMasterSlaveVServerGroupOutcome(CreateMasterSlaveVServerGroupResult(outcome.result()));
else
return CreateMasterSlaveVServerGroupOutcome(outcome.error());
}
void SlbClient::createMasterSlaveVServerGroupAsync(const CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createMasterSlaveVServerGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::CreateMasterSlaveVServerGroupOutcomeCallable SlbClient::createMasterSlaveVServerGroupCallable(const CreateMasterSlaveVServerGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateMasterSlaveVServerGroupOutcome()>>(
[this, request]()
{
return this->createMasterSlaveVServerGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateRulesOutcome SlbClient::createRules(const CreateRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,6 +555,42 @@ SlbClient::CreateRulesOutcomeCallable SlbClient::createRulesCallable(const Creat
return task->get_future();
}
SlbClient::CreateTLSCipherPolicyOutcome SlbClient::createTLSCipherPolicy(const CreateTLSCipherPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateTLSCipherPolicyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateTLSCipherPolicyOutcome(CreateTLSCipherPolicyResult(outcome.result()));
else
return CreateTLSCipherPolicyOutcome(outcome.error());
}
void SlbClient::createTLSCipherPolicyAsync(const CreateTLSCipherPolicyRequest& request, const CreateTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createTLSCipherPolicy(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::CreateTLSCipherPolicyOutcomeCallable SlbClient::createTLSCipherPolicyCallable(const CreateTLSCipherPolicyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateTLSCipherPolicyOutcome()>>(
[this, request]()
{
return this->createTLSCipherPolicy(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateVServerGroupOutcome SlbClient::createVServerGroup(const CreateVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,42 +843,6 @@ SlbClient::DeleteMasterSlaveServerGroupOutcomeCallable SlbClient::deleteMasterSl
return task->get_future();
}
SlbClient::DeleteMasterSlaveVServerGroupOutcome SlbClient::deleteMasterSlaveVServerGroup(const DeleteMasterSlaveVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteMasterSlaveVServerGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteMasterSlaveVServerGroupOutcome(DeleteMasterSlaveVServerGroupResult(outcome.result()));
else
return DeleteMasterSlaveVServerGroupOutcome(outcome.error());
}
void SlbClient::deleteMasterSlaveVServerGroupAsync(const DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteMasterSlaveVServerGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DeleteMasterSlaveVServerGroupOutcomeCallable SlbClient::deleteMasterSlaveVServerGroupCallable(const DeleteMasterSlaveVServerGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteMasterSlaveVServerGroupOutcome()>>(
[this, request]()
{
return this->deleteMasterSlaveVServerGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DeleteRulesOutcome SlbClient::deleteRules(const DeleteRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -951,6 +915,42 @@ SlbClient::DeleteServerCertificateOutcomeCallable SlbClient::deleteServerCertifi
return task->get_future();
}
SlbClient::DeleteTLSCipherPolicyOutcome SlbClient::deleteTLSCipherPolicy(const DeleteTLSCipherPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteTLSCipherPolicyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteTLSCipherPolicyOutcome(DeleteTLSCipherPolicyResult(outcome.result()));
else
return DeleteTLSCipherPolicyOutcome(outcome.error());
}
void SlbClient::deleteTLSCipherPolicyAsync(const DeleteTLSCipherPolicyRequest& request, const DeleteTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteTLSCipherPolicy(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DeleteTLSCipherPolicyOutcomeCallable SlbClient::deleteTLSCipherPolicyCallable(const DeleteTLSCipherPolicyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteTLSCipherPolicyOutcome()>>(
[this, request]()
{
return this->deleteTLSCipherPolicy(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DeleteVServerGroupOutcome SlbClient::deleteVServerGroup(const DeleteVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,42 +1383,6 @@ SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::
return task->get_future();
}
SlbClient::DescribeLoadBalancerListenersExOutcome SlbClient::describeLoadBalancerListenersEx(const DescribeLoadBalancerListenersExRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLoadBalancerListenersExOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLoadBalancerListenersExOutcome(DescribeLoadBalancerListenersExResult(outcome.result()));
else
return DescribeLoadBalancerListenersExOutcome(outcome.error());
}
void SlbClient::describeLoadBalancerListenersExAsync(const DescribeLoadBalancerListenersExRequest& request, const DescribeLoadBalancerListenersExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLoadBalancerListenersEx(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeLoadBalancerListenersExOutcomeCallable SlbClient::describeLoadBalancerListenersExCallable(const DescribeLoadBalancerListenersExRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLoadBalancerListenersExOutcome()>>(
[this, request]()
{
return this->describeLoadBalancerListenersEx(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeLoadBalancerTCPListenerAttributeOutcome SlbClient::describeLoadBalancerTCPListenerAttribute(const DescribeLoadBalancerTCPListenerAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1599,78 +1563,6 @@ SlbClient::DescribeMasterSlaveServerGroupsOutcomeCallable SlbClient::describeMas
return task->get_future();
}
SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcome SlbClient::describeMasterSlaveVServerGroupAttribute(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMasterSlaveVServerGroupAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMasterSlaveVServerGroupAttributeOutcome(DescribeMasterSlaveVServerGroupAttributeResult(outcome.result()));
else
return DescribeMasterSlaveVServerGroupAttributeOutcome(outcome.error());
}
void SlbClient::describeMasterSlaveVServerGroupAttributeAsync(const DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMasterSlaveVServerGroupAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcomeCallable SlbClient::describeMasterSlaveVServerGroupAttributeCallable(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMasterSlaveVServerGroupAttributeOutcome()>>(
[this, request]()
{
return this->describeMasterSlaveVServerGroupAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeMasterSlaveVServerGroupsOutcome SlbClient::describeMasterSlaveVServerGroups(const DescribeMasterSlaveVServerGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMasterSlaveVServerGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMasterSlaveVServerGroupsOutcome(DescribeMasterSlaveVServerGroupsResult(outcome.result()));
else
return DescribeMasterSlaveVServerGroupsOutcome(outcome.error());
}
void SlbClient::describeMasterSlaveVServerGroupsAsync(const DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMasterSlaveVServerGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeMasterSlaveVServerGroupsOutcomeCallable SlbClient::describeMasterSlaveVServerGroupsCallable(const DescribeMasterSlaveVServerGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMasterSlaveVServerGroupsOutcome()>>(
[this, request]()
{
return this->describeMasterSlaveVServerGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeRegionsOutcome SlbClient::describeRegions(const DescribeRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +1851,42 @@ SlbClient::DescribeZonesOutcomeCallable SlbClient::describeZonesCallable(const D
return task->get_future();
}
SlbClient::ListTLSCipherPoliciesOutcome SlbClient::listTLSCipherPolicies(const ListTLSCipherPoliciesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTLSCipherPoliciesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTLSCipherPoliciesOutcome(ListTLSCipherPoliciesResult(outcome.result()));
else
return ListTLSCipherPoliciesOutcome(outcome.error());
}
void SlbClient::listTLSCipherPoliciesAsync(const ListTLSCipherPoliciesRequest& request, const ListTLSCipherPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTLSCipherPolicies(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::ListTLSCipherPoliciesOutcomeCallable SlbClient::listTLSCipherPoliciesCallable(const ListTLSCipherPoliciesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTLSCipherPoliciesOutcome()>>(
[this, request]()
{
return this->listTLSCipherPolicies(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::ListTagResourcesOutcome SlbClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2607,36 +2535,36 @@ SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::setLo
return task->get_future();
}
SlbClient::SetLoadBalancerListenerAttributeExOutcome SlbClient::setLoadBalancerListenerAttributeEx(const SetLoadBalancerListenerAttributeExRequest &request) const
SlbClient::SetLoadBalancerModificationProtectionOutcome SlbClient::setLoadBalancerModificationProtection(const SetLoadBalancerModificationProtectionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetLoadBalancerListenerAttributeExOutcome(endpointOutcome.error());
return SetLoadBalancerModificationProtectionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetLoadBalancerListenerAttributeExOutcome(SetLoadBalancerListenerAttributeExResult(outcome.result()));
return SetLoadBalancerModificationProtectionOutcome(SetLoadBalancerModificationProtectionResult(outcome.result()));
else
return SetLoadBalancerListenerAttributeExOutcome(outcome.error());
return SetLoadBalancerModificationProtectionOutcome(outcome.error());
}
void SlbClient::setLoadBalancerListenerAttributeExAsync(const SetLoadBalancerListenerAttributeExRequest& request, const SetLoadBalancerListenerAttributeExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void SlbClient::setLoadBalancerModificationProtectionAsync(const SetLoadBalancerModificationProtectionRequest& request, const SetLoadBalancerModificationProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setLoadBalancerListenerAttributeEx(request), context);
handler(this, request, setLoadBalancerModificationProtection(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetLoadBalancerListenerAttributeExOutcomeCallable SlbClient::setLoadBalancerListenerAttributeExCallable(const SetLoadBalancerListenerAttributeExRequest &request) const
SlbClient::SetLoadBalancerModificationProtectionOutcomeCallable SlbClient::setLoadBalancerModificationProtectionCallable(const SetLoadBalancerModificationProtectionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetLoadBalancerListenerAttributeExOutcome()>>(
auto task = std::make_shared<std::packaged_task<SetLoadBalancerModificationProtectionOutcome()>>(
[this, request]()
{
return this->setLoadBalancerListenerAttributeEx(request);
return this->setLoadBalancerModificationProtection(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -2859,6 +2787,42 @@ SlbClient::SetServerCertificateNameOutcomeCallable SlbClient::setServerCertifica
return task->get_future();
}
SlbClient::SetTLSCipherPolicyAttributeOutcome SlbClient::setTLSCipherPolicyAttribute(const SetTLSCipherPolicyAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetTLSCipherPolicyAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetTLSCipherPolicyAttributeOutcome(SetTLSCipherPolicyAttributeResult(outcome.result()));
else
return SetTLSCipherPolicyAttributeOutcome(outcome.error());
}
void SlbClient::setTLSCipherPolicyAttributeAsync(const SetTLSCipherPolicyAttributeRequest& request, const SetTLSCipherPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setTLSCipherPolicyAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetTLSCipherPolicyAttributeOutcomeCallable SlbClient::setTLSCipherPolicyAttributeCallable(const SetTLSCipherPolicyAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetTLSCipherPolicyAttributeOutcome()>>(
[this, request]()
{
return this->setTLSCipherPolicyAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::SetVServerGroupAttributeOutcome SlbClient::setVServerGroupAttribute(const SetVServerGroupAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

30
slb/src/model/CreateDomainExtensionRequest.cc
View File

@@ -49,6 +49,23 @@ void CreateDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<CreateDomainExtensionRequest::ServerCertificate> CreateDomainExtensionRequest::getServerCertificate()const
{
return serverCertificate_;
}
void CreateDomainExtensionRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
std::string CreateDomainExtensionRequest::getRegionId()const
{
return regionId_;
@@ -93,6 +110,19 @@ void CreateDomainExtensionRequest::setOwnerAccount(const std::string& ownerAccou
setParameter("OwnerAccount", ownerAccount);
}
std::vector<std::string> CreateDomainExtensionRequest::getCertificateId()const
{
return certificateId_;
}
void CreateDomainExtensionRequest::setCertificateId(const std::vector<std::string>& certificateId)
{
certificateId_ = certificateId;
for(int dep1 = 0; dep1!= certificateId.size(); dep1++) {
setParameter("CertificateId."+ std::to_string(dep1), certificateId.at(dep1));
}
}
long CreateDomainExtensionRequest::getOwnerId()const
{
return ownerId_;

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

@@ -38,6 +38,23 @@ void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerId(long resourceOwn
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<CreateLoadBalancerHTTPSListenerRequest::ServerCertificate> CreateLoadBalancerHTTPSListenerRequest::getServerCertificate()const
{
return serverCertificate_;
}
void CreateLoadBalancerHTTPSListenerRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckTimeout()const
{
return healthCheckTimeout_;

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

@@ -27,17 +27,6 @@ CreateLoadBalancerRequest::CreateLoadBalancerRequest() :
CreateLoadBalancerRequest::~CreateLoadBalancerRequest()
{}
std::string CreateLoadBalancerRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long CreateLoadBalancerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
@@ -49,39 +38,6 @@ void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool CreateLoadBalancerRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void CreateLoadBalancerRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
}
void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getCloudType()const
{
return cloudType_;
}
void CreateLoadBalancerRequest::setCloudType(const std::string& cloudType)
{
cloudType_ = cloudType;
setParameter("CloudType", cloudType);
}
std::string CreateLoadBalancerRequest::getAddressIPVersion()const
{
return addressIPVersion_;
@@ -104,17 +60,6 @@ void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
setParameter("MasterZoneId", masterZoneId);
}
int CreateLoadBalancerRequest::getDuration()const
{
return duration_;
}
void CreateLoadBalancerRequest::setDuration(int duration)
{
duration_ = duration;
setParameter("Duration", std::to_string(duration));
}
std::string CreateLoadBalancerRequest::getResourceGroupId()const
{
return resourceGroupId_;
@@ -137,28 +82,6 @@ void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalan
setParameter("LoadBalancerName", loadBalancerName);
}
std::string CreateLoadBalancerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateLoadBalancerRequest::getAddressType()const
{
return addressType_;
}
void CreateLoadBalancerRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string CreateLoadBalancerRequest::getSlaveZoneId()const
{
return slaveZoneId_;
@@ -170,17 +93,6 @@ void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
setParameter("SlaveZoneId", slaveZoneId);
}
std::string CreateLoadBalancerRequest::getDeleteProtection()const
{
return deleteProtection_;
}
void CreateLoadBalancerRequest::setDeleteProtection(const std::string& deleteProtection)
{
deleteProtection_ = deleteProtection;
setParameter("DeleteProtection", deleteProtection);
}
std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
@@ -192,61 +104,6 @@ void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalan
setParameter("LoadBalancerSpec", loadBalancerSpec);
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
}
void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
{
autoPay_ = autoPay;
setParameter("AutoPay", autoPay ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getAddress()const
{
return address_;
}
void CreateLoadBalancerRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
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_;
@@ -302,6 +159,182 @@ void CreateLoadBalancerRequest::setInternetChargeType(const std::string& interne
setParameter("InternetChargeType", internetChargeType);
}
std::string CreateLoadBalancerRequest::getPricingCycle()const
{
return pricingCycle_;
}
void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle)
{
pricingCycle_ = pricingCycle;
setParameter("PricingCycle", pricingCycle);
}
std::string CreateLoadBalancerRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
std::string CreateLoadBalancerRequest::getModificationProtectionReason()const
{
return modificationProtectionReason_;
}
void CreateLoadBalancerRequest::setModificationProtectionReason(const std::string& modificationProtectionReason)
{
modificationProtectionReason_ = modificationProtectionReason;
setParameter("ModificationProtectionReason", modificationProtectionReason);
}
bool CreateLoadBalancerRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void CreateLoadBalancerRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
}
void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getCloudType()const
{
return cloudType_;
}
void CreateLoadBalancerRequest::setCloudType(const std::string& cloudType)
{
cloudType_ = cloudType;
setParameter("CloudType", cloudType);
}
int CreateLoadBalancerRequest::getDuration()const
{
return duration_;
}
void CreateLoadBalancerRequest::setDuration(int duration)
{
duration_ = duration;
setParameter("Duration", std::to_string(duration));
}
std::string CreateLoadBalancerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateLoadBalancerRequest::getAddressType()const
{
return addressType_;
}
void CreateLoadBalancerRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string CreateLoadBalancerRequest::getDeleteProtection()const
{
return deleteProtection_;
}
void CreateLoadBalancerRequest::setDeleteProtection(const std::string& deleteProtection)
{
deleteProtection_ = deleteProtection;
setParameter("DeleteProtection", deleteProtection);
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
}
void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
{
autoPay_ = autoPay;
setParameter("AutoPay", autoPay ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getAddress()const
{
return address_;
}
void CreateLoadBalancerRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
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);
}
std::string CreateLoadBalancerRequest::getModificationProtectionStatus()const
{
return modificationProtectionStatus_;
}
void CreateLoadBalancerRequest::setModificationProtectionStatus(const std::string& modificationProtectionStatus)
{
modificationProtectionStatus_ = modificationProtectionStatus;
setParameter("ModificationProtectionStatus", modificationProtectionStatus);
}
std::string CreateLoadBalancerRequest::getVpcId()const
{
return vpcId_;
@@ -324,17 +357,6 @@ void CreateLoadBalancerRequest::setPayType(const std::string& payType)
setParameter("PayType", payType);
}
std::string CreateLoadBalancerRequest::getPricingCycle()const
{
return pricingCycle_;
}
void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle)
{
pricingCycle_ = pricingCycle;
setParameter("PricingCycle", pricingCycle);
}
int CreateLoadBalancerRequest::getRatio()const
{
return ratio_;

148
slb/src/model/CreateMasterSlaveVServerGroupRequest.cc
View File

@@ -1,148 +0,0 @@
/*
* 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/CreateMasterSlaveVServerGroupRequest.h>
using AlibabaCloud::Slb::Model::CreateMasterSlaveVServerGroupRequest;
CreateMasterSlaveVServerGroupRequest::CreateMasterSlaveVServerGroupRequest() :
RpcServiceRequest("slb", "2014-05-15", "CreateMasterSlaveVServerGroup")
{}
CreateMasterSlaveVServerGroupRequest::~CreateMasterSlaveVServerGroupRequest()
{}
std::string CreateMasterSlaveVServerGroupRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long CreateMasterSlaveVServerGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateMasterSlaveVServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}
void CreateMasterSlaveVServerGroupRequest::setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers)
{
masterSlaveBackendServers_ = masterSlaveBackendServers;
setCoreParameter("MasterSlaveBackendServers", masterSlaveBackendServers);
}
std::string CreateMasterSlaveVServerGroupRequest::getRegionId()const
{
return regionId_;
}
void CreateMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateMasterSlaveVServerGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupName()const
{
return masterSlaveVServerGroupName_;
}
void CreateMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName)
{
masterSlaveVServerGroupName_ = masterSlaveVServerGroupName;
setCoreParameter("MasterSlaveVServerGroupName", masterSlaveVServerGroupName);
}
long CreateMasterSlaveVServerGroupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMasterSlaveVServerGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMasterSlaveVServerGroupRequest::getTags()const
{
return tags_;
}
void CreateMasterSlaveVServerGroupRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}
std::string CreateMasterSlaveVServerGroupRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void CreateMasterSlaveVServerGroupRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setCoreParameter("LoadBalancerId", loadBalancerId);
}

80
slb/src/model/CreateMasterSlaveVServerGroupResult.cc
View File

@@ -1,80 +0,0 @@
/*
* 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/CreateMasterSlaveVServerGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult() :
ServiceResult()
{}
CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateMasterSlaveVServerGroupResult::~CreateMasterSlaveVServerGroupResult()
{}
void CreateMasterSlaveVServerGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
{
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].isNull())
masterSlaveBackendServersObject.isBackup = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].isNull())
masterSlaveBackendServersObject.eniHost = valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
}
std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
std::vector<CreateMasterSlaveVServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveVServerGroupResult::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}

143
slb/src/model/CreateTLSCipherPolicyRequest.cc Normal file
View File

@@ -0,0 +1,143 @@
/*
* 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/CreateTLSCipherPolicyRequest.h>
using AlibabaCloud::Slb::Model::CreateTLSCipherPolicyRequest;
CreateTLSCipherPolicyRequest::CreateTLSCipherPolicyRequest() :
RpcServiceRequest("slb", "2014-05-15", "CreateTLSCipherPolicy")
{
setMethod(HttpRequest::Method::Post);
}
CreateTLSCipherPolicyRequest::~CreateTLSCipherPolicyRequest()
{}
std::string CreateTLSCipherPolicyRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateTLSCipherPolicyRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long CreateTLSCipherPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateTLSCipherPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateTLSCipherPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateTLSCipherPolicyRequest::getRegionId()const
{
return regionId_;
}
void CreateTLSCipherPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<std::string> CreateTLSCipherPolicyRequest::getCiphers()const
{
return ciphers_;
}
void CreateTLSCipherPolicyRequest::setCiphers(const std::vector<std::string>& ciphers)
{
ciphers_ = ciphers;
for(int dep1 = 0; dep1!= ciphers.size(); dep1++) {
setParameter("Ciphers."+ std::to_string(dep1), ciphers.at(dep1));
}
}
std::vector<std::string> CreateTLSCipherPolicyRequest::getTLSVersions()const
{
return tLSVersions_;
}
void CreateTLSCipherPolicyRequest::setTLSVersions(const std::vector<std::string>& tLSVersions)
{
tLSVersions_ = tLSVersions;
for(int dep1 = 0; dep1!= tLSVersions.size(); dep1++) {
setParameter("TLSVersions."+ std::to_string(dep1), tLSVersions.at(dep1));
}
}
std::string CreateTLSCipherPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateTLSCipherPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateTLSCipherPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateTLSCipherPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void CreateTLSCipherPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateTLSCipherPolicyRequest::getName()const
{
return name_;
}
void CreateTLSCipherPolicyRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
slb/src/model/CreateTLSCipherPolicyResult.cc Normal file
View File

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

126
slb/src/model/DeleteMasterSlaveVServerGroupRequest.cc
View File

@@ -1,126 +0,0 @@
/*
* 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/DeleteMasterSlaveVServerGroupRequest.h>
using AlibabaCloud::Slb::Model::DeleteMasterSlaveVServerGroupRequest;
DeleteMasterSlaveVServerGroupRequest::DeleteMasterSlaveVServerGroupRequest() :
RpcServiceRequest("slb", "2014-05-15", "DeleteMasterSlaveVServerGroup")
{}
DeleteMasterSlaveVServerGroupRequest::~DeleteMasterSlaveVServerGroupRequest()
{}
std::string DeleteMasterSlaveVServerGroupRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DeleteMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long DeleteMasterSlaveVServerGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteMasterSlaveVServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DeleteMasterSlaveVServerGroupRequest::getRegionId()const
{
return regionId_;
}
void DeleteMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DeleteMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
void DeleteMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
{
masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
setCoreParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId);
}
std::string DeleteMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteMasterSlaveVServerGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long DeleteMasterSlaveVServerGroupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteMasterSlaveVServerGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteMasterSlaveVServerGroupRequest::getTags()const
{
return tags_;
}
void DeleteMasterSlaveVServerGroupRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}

117
slb/src/model/DeleteTLSCipherPolicyRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/DeleteTLSCipherPolicyRequest.h>
using AlibabaCloud::Slb::Model::DeleteTLSCipherPolicyRequest;
DeleteTLSCipherPolicyRequest::DeleteTLSCipherPolicyRequest() :
RpcServiceRequest("slb", "2014-05-15", "DeleteTLSCipherPolicy")
{
setMethod(HttpRequest::Method::Post);
}
DeleteTLSCipherPolicyRequest::~DeleteTLSCipherPolicyRequest()
{}
std::string DeleteTLSCipherPolicyRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DeleteTLSCipherPolicyRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long DeleteTLSCipherPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteTLSCipherPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteTLSCipherPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteTLSCipherPolicyRequest::getTLSCipherPolicyId()const
{
return tLSCipherPolicyId_;
}
void DeleteTLSCipherPolicyRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
{
tLSCipherPolicyId_ = tLSCipherPolicyId;
setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
}
std::string DeleteTLSCipherPolicyRequest::getRegionId()const
{
return regionId_;
}
void DeleteTLSCipherPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteTLSCipherPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteTLSCipherPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteTLSCipherPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteTLSCipherPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteTLSCipherPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

10
slb/src/model/DeleteMasterSlaveVServerGroupResult.cc → slb/src/model/DeleteTLSCipherPolicyResult.cc
View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h>
#include <alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult() :
DeleteTLSCipherPolicyResult::DeleteTLSCipherPolicyResult() :
ServiceResult()
{}
DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult(const std::string &payload) :
DeleteTLSCipherPolicyResult::DeleteTLSCipherPolicyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteMasterSlaveVServerGroupResult::~DeleteMasterSlaveVServerGroupResult()
DeleteTLSCipherPolicyResult::~DeleteTLSCipherPolicyResult()
{}
void DeleteMasterSlaveVServerGroupResult::parse(const std::string &payload)
void DeleteTLSCipherPolicyResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;

12
slb/src/model/DescribeAccessControlListsResult.cc
View File

@@ -51,14 +51,14 @@ void DescribeAccessControlListsResult::parse(const std::string &payload)
aclsObject.addressIPVersion = valueAclsAcl["AddressIPVersion"].asString();
if(!valueAclsAcl["ResourceGroupId"].isNull())
aclsObject.resourceGroupId = valueAclsAcl["ResourceGroupId"].asString();
auto allTagsNode = allAclsNode["Tags"]["Tag"];
for (auto allAclsNodeTagsTag : allTagsNode)
auto allTagsNode = valueAclsAcl["Tags"]["Tag"];
for (auto valueAclsAclTagsTag : allTagsNode)
{
Acl::Tag tagsObject;
if(!allAclsNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allAclsNodeTagsTag["TagKey"].asString();
if(!allAclsNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allAclsNodeTagsTag["TagValue"].asString();
if(!valueAclsAclTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueAclsAclTagsTag["TagKey"].asString();
if(!valueAclsAclTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueAclsAclTagsTag["TagValue"].asString();
aclsObject.tags.push_back(tagsObject);
}
acls_.push_back(aclsObject);

12
slb/src/model/DescribeAvailableResourceResult.cc
View File

@@ -47,14 +47,14 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
availableResourcesObject.masterZoneId = valueAvailableResourcesAvailableResource["MasterZoneId"].asString();
if(!valueAvailableResourcesAvailableResource["SlaveZoneId"].isNull())
availableResourcesObject.slaveZoneId = valueAvailableResourcesAvailableResource["SlaveZoneId"].asString();
auto allSupportResourcesNode = allAvailableResourcesNode["SupportResources"]["SupportResource"];
for (auto allAvailableResourcesNodeSupportResourcesSupportResource : allSupportResourcesNode)
auto allSupportResourcesNode = valueAvailableResourcesAvailableResource["SupportResources"]["SupportResource"];
for (auto valueAvailableResourcesAvailableResourceSupportResourcesSupportResource : allSupportResourcesNode)
{
AvailableResource::SupportResource supportResourcesObject;
if(!allAvailableResourcesNodeSupportResourcesSupportResource["AddressType"].isNull())
supportResourcesObject.addressType = allAvailableResourcesNodeSupportResourcesSupportResource["AddressType"].asString();
if(!allAvailableResourcesNodeSupportResourcesSupportResource["AddressIPVersion"].isNull())
supportResourcesObject.addressIPVersion = allAvailableResourcesNodeSupportResourcesSupportResource["AddressIPVersion"].asString();
if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].isNull())
supportResourcesObject.addressType = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].asString();
if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].isNull())
supportResourcesObject.addressIPVersion = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].asString();
availableResourcesObject.supportResources.push_back(supportResourcesObject);
}
availableResources_.push_back(availableResourcesObject);

18
slb/src/model/DescribeCACertificatesResult.cc
View File

@@ -63,14 +63,20 @@ void DescribeCACertificatesResult::parse(const std::string &payload)
cACertificatesObject.expireTimeStamp = std::stol(valueCACertificatesCACertificate["ExpireTimeStamp"].asString());
if(!valueCACertificatesCACertificate["CommonName"].isNull())
cACertificatesObject.commonName = valueCACertificatesCACertificate["CommonName"].asString();
auto allTagsNode = allCACertificatesNode["Tags"]["Tag"];
for (auto allCACertificatesNodeTagsTag : allTagsNode)
if(!valueCACertificatesCACertificate["EncryptionAlgorithm"].isNull())
cACertificatesObject.encryptionAlgorithm = valueCACertificatesCACertificate["EncryptionAlgorithm"].asString();
if(!valueCACertificatesCACertificate["EncryptionKeyLength"].isNull())
cACertificatesObject.encryptionKeyLength = std::stoi(valueCACertificatesCACertificate["EncryptionKeyLength"].asString());
if(!valueCACertificatesCACertificate["StandardType"].isNull())
cACertificatesObject.standardType = valueCACertificatesCACertificate["StandardType"].asString();
auto allTagsNode = valueCACertificatesCACertificate["Tags"]["Tag"];
for (auto valueCACertificatesCACertificateTagsTag : allTagsNode)
{
CACertificate::Tag tagsObject;
if(!allCACertificatesNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allCACertificatesNodeTagsTag["TagKey"].asString();
if(!allCACertificatesNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allCACertificatesNodeTagsTag["TagValue"].asString();
if(!valueCACertificatesCACertificateTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueCACertificatesCACertificateTagsTag["TagKey"].asString();
if(!valueCACertificatesCACertificateTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueCACertificatesCACertificateTagsTag["TagValue"].asString();
cACertificatesObject.tags.push_back(tagsObject);
}
cACertificates_.push_back(cACertificatesObject);

34
slb/src/model/DescribeDomainExtensionAttributeResult.cc
View File

@@ -39,6 +39,30 @@ void DescribeDomainExtensionAttributeResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCertificatesNode = value["Certificates"]["Certificate"];
for (auto valueCertificatesCertificate : allCertificatesNode)
{
Certificate certificatesObject;
if(!valueCertificatesCertificate["CertificateId"].isNull())
certificatesObject.certificateId = valueCertificatesCertificate["CertificateId"].asString();
if(!valueCertificatesCertificate["EncryptionAlgorithm"].isNull())
certificatesObject.encryptionAlgorithm = valueCertificatesCertificate["EncryptionAlgorithm"].asString();
certificates_.push_back(certificatesObject);
}
auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
{
ServerCertificate serverCertificatesObject;
if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
serverCertificates_.push_back(serverCertificatesObject);
}
if(!value["DomainExtensionId"].isNull())
domainExtensionId_ = value["DomainExtensionId"].asString();
if(!value["Domain"].isNull())
@@ -62,6 +86,16 @@ int DescribeDomainExtensionAttributeResult::getListenerPort()const
return listenerPort_;
}
std::vector<DescribeDomainExtensionAttributeResult::Certificate> DescribeDomainExtensionAttributeResult::getCertificates()const
{
return certificates_;
}
std::vector<DescribeDomainExtensionAttributeResult::ServerCertificate> DescribeDomainExtensionAttributeResult::getServerCertificates()const
{
return serverCertificates_;
}
std::string DescribeDomainExtensionAttributeResult::getServerCertificateId()const
{
return serverCertificateId_;

24
slb/src/model/DescribeDomainExtensionsResult.cc
View File

@@ -49,6 +49,30 @@ void DescribeDomainExtensionsResult::parse(const std::string &payload)
domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
{
DomainExtension::Certificate certificatesObject;
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
domainExtensionsObject.certificates.push_back(certificatesObject);
}
auto allServerCertificatesNode = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificatesNode)
{
DomainExtension::ServerCertificate serverCertificatesObject;
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificatesObject.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificatesObject.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
domainExtensionsObject.serverCertificates.push_back(serverCertificatesObject);
}
domainExtensions_.push_back(domainExtensionsObject);
}

21
slb/src/model/DescribeLoadBalancerAttributeResult.cc
View File

@@ -169,6 +169,12 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
cloudInstanceUid_ = std::stol(value["CloudInstanceUid"].asString());
if(!value["SupportPrivateLink"].isNull())
supportPrivateLink_ = value["SupportPrivateLink"].asString() == "true";
if(!value["BusinessStatus"].isNull())
businessStatus_ = value["BusinessStatus"].asString();
if(!value["ModificationProtectionStatus"].isNull())
modificationProtectionStatus_ = value["ModificationProtectionStatus"].asString();
if(!value["ModificationProtectionReason"].isNull())
modificationProtectionReason_ = value["ModificationProtectionReason"].asString();
}
@@ -232,11 +238,21 @@ std::string DescribeLoadBalancerAttributeResult::getHasReservedInfo()const
return hasReservedInfo_;
}
std::string DescribeLoadBalancerAttributeResult::getBusinessStatus()const
{
return businessStatus_;
}
std::string DescribeLoadBalancerAttributeResult::getReservedInfoBandwidth()const
{
return reservedInfoBandwidth_;
}
std::string DescribeLoadBalancerAttributeResult::getModificationProtectionStatus()const
{
return modificationProtectionStatus_;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
@@ -252,6 +268,11 @@ int DescribeLoadBalancerAttributeResult::getBandwidth()const
return bandwidth_;
}
std::string DescribeLoadBalancerAttributeResult::getModificationProtectionReason()const
{
return modificationProtectionReason_;
}
std::string DescribeLoadBalancerAttributeResult::getAssociatedCenId()const
{
return associatedCenId_;

43
slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
View File

@@ -65,8 +65,46 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
{
DomainExtension::Certificate certificatesObject;
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
domainExtensionsObject.certificates.push_back(certificatesObject);
}
auto allServerCertificates1Node = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificates1Node)
{
DomainExtension::ServerCertificate serverCertificates1Object;
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificates1Object.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificates1Object.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificates1Object.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificates1Object.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
domainExtensionsObject.serverCertificates1.push_back(serverCertificates1Object);
}
domainExtensions_.push_back(domainExtensionsObject);
}
auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
{
ServerCertificate2 serverCertificatesObject;
if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
serverCertificates_.push_back(serverCertificatesObject);
}
auto allAclIds = value["AclIds"]["AclId"];
for (const auto &item : allAclIds)
aclIds_.push_back(item.asString());
@@ -250,6 +288,11 @@ std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId
return cACertificateId_;
}
std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::ServerCertificate2> DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificates()const
{
return serverCertificates_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertFingerprintAlias()const
{
return xForwardedFor_ClientCertFingerprintAlias_;

73
slb/src/model/DescribeLoadBalancerListenersExRequest.cc
View File

@@ -1,73 +0,0 @@
/*
* 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/DescribeLoadBalancerListenersExRequest.h>
using AlibabaCloud::Slb::Model::DescribeLoadBalancerListenersExRequest;
DescribeLoadBalancerListenersExRequest::DescribeLoadBalancerListenersExRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerListenersEx")
{
setMethod(HttpRequest::Method::Post);
}
DescribeLoadBalancerListenersExRequest::~DescribeLoadBalancerListenersExRequest()
{}
int DescribeLoadBalancerListenersExRequest::getListenerPort()const
{
return listenerPort_;
}
void DescribeLoadBalancerListenersExRequest::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
setParameter("ListenerPort", std::to_string(listenerPort));
}
std::string DescribeLoadBalancerListenersExRequest::getProtocol()const
{
return protocol_;
}
void DescribeLoadBalancerListenersExRequest::setProtocol(const std::string& protocol)
{
protocol_ = protocol;
setParameter("Protocol", protocol);
}
std::string DescribeLoadBalancerListenersExRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeLoadBalancerListenersExRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DescribeLoadBalancerListenersExRequest::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancerListenersExRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

68
slb/src/model/DescribeLoadBalancerListenersExResult.cc
View File

@@ -1,68 +0,0 @@
/*
* 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/DescribeLoadBalancerListenersExResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeLoadBalancerListenersExResult::DescribeLoadBalancerListenersExResult() :
ServiceResult()
{}
DescribeLoadBalancerListenersExResult::DescribeLoadBalancerListenersExResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLoadBalancerListenersExResult::~DescribeLoadBalancerListenersExResult()
{}
void DescribeLoadBalancerListenersExResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allListenerExtendedAttributesNode = value["ListenerExtendedAttributes"]["ListenerAttributeExResponseModel"];
for (auto valueListenerExtendedAttributesListenerAttributeExResponseModel : allListenerExtendedAttributesNode)
{
ListenerAttributeExResponseModel listenerExtendedAttributesObject;
if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["ListenerPort"].isNull())
listenerExtendedAttributesObject.listenerPort = std::stoi(valueListenerExtendedAttributesListenerAttributeExResponseModel["ListenerPort"].asString());
if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["Protocol"].isNull())
listenerExtendedAttributesObject.protocol = valueListenerExtendedAttributesListenerAttributeExResponseModel["Protocol"].asString();
if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["RecordCustomizedHeaders"].isNull())
listenerExtendedAttributesObject.recordCustomizedHeaders = valueListenerExtendedAttributesListenerAttributeExResponseModel["RecordCustomizedHeaders"].asString();
listenerExtendedAttributes_.push_back(listenerExtendedAttributesObject);
}
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
}
std::string DescribeLoadBalancerListenersExResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
std::vector<DescribeLoadBalancerListenersExResult::ListenerAttributeExResponseModel> DescribeLoadBalancerListenersExResult::getListenerExtendedAttributes()const
{
return listenerExtendedAttributes_;
}

253
slb/src/model/DescribeLoadBalancersRequest.cc
View File

@@ -27,17 +27,6 @@ DescribeLoadBalancersRequest::DescribeLoadBalancersRequest() :
DescribeLoadBalancersRequest::~DescribeLoadBalancersRequest()
{}
std::string DescribeLoadBalancersRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long DescribeLoadBalancersRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
@@ -49,17 +38,6 @@ void DescribeLoadBalancersRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool DescribeLoadBalancersRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
std::string DescribeLoadBalancersRequest::getNetworkType()const
{
return networkType_;
@@ -93,17 +71,6 @@ void DescribeLoadBalancersRequest::setMasterZoneId(const std::string& masterZone
setParameter("MasterZoneId", masterZoneId);
}
int DescribeLoadBalancersRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeLoadBalancersRequest::getResourceGroupId()const
{
return resourceGroupId_;
@@ -126,39 +93,6 @@ void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBa
setParameter("LoadBalancerName", loadBalancerName);
}
std::string DescribeLoadBalancersRequest::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int DescribeLoadBalancersRequest::getPageSize()const
{
return pageSize_;
}
void DescribeLoadBalancersRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeLoadBalancersRequest::getAddressType()const
{
return addressType_;
}
void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string DescribeLoadBalancersRequest::getSlaveZoneId()const
{
return slaveZoneId_;
@@ -186,50 +120,6 @@ void DescribeLoadBalancersRequest::setTag(const std::vector<Tag>& tag)
}
}
std::string DescribeLoadBalancersRequest::getFuzzy()const
{
return fuzzy_;
}
void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
{
fuzzy_ = fuzzy;
setParameter("Fuzzy", fuzzy);
}
std::string DescribeLoadBalancersRequest::getAddress()const
{
return address_;
}
void DescribeLoadBalancersRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeLoadBalancersRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeLoadBalancersRequest::getOwnerId()const
{
return ownerId_;
@@ -252,17 +142,6 @@ void DescribeLoadBalancersRequest::setServerId(const std::string& serverId)
setParameter("ServerId", serverId);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
{
return loadBalancerStatus_;
}
void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
{
loadBalancerStatus_ = loadBalancerStatus;
setParameter("LoadBalancerStatus", loadBalancerStatus);
}
std::string DescribeLoadBalancersRequest::getTags()const
{
return tags_;
@@ -318,6 +197,138 @@ void DescribeLoadBalancersRequest::setInternetChargeType(const std::string& inte
setParameter("InternetChargeType", internetChargeType);
}
std::string DescribeLoadBalancersRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
bool DescribeLoadBalancersRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
int DescribeLoadBalancersRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeLoadBalancersRequest::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int DescribeLoadBalancersRequest::getPageSize()const
{
return pageSize_;
}
void DescribeLoadBalancersRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeLoadBalancersRequest::getAddressType()const
{
return addressType_;
}
void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string DescribeLoadBalancersRequest::getFuzzy()const
{
return fuzzy_;
}
void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
{
fuzzy_ = fuzzy;
setParameter("Fuzzy", fuzzy);
}
std::string DescribeLoadBalancersRequest::getBusinessStatus()const
{
return businessStatus_;
}
void DescribeLoadBalancersRequest::setBusinessStatus(const std::string& businessStatus)
{
businessStatus_ = businessStatus;
setParameter("BusinessStatus", businessStatus);
}
std::string DescribeLoadBalancersRequest::getAddress()const
{
return address_;
}
void DescribeLoadBalancersRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeLoadBalancersRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
{
return loadBalancerStatus_;
}
void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
{
loadBalancerStatus_ = loadBalancerStatus;
setParameter("LoadBalancerStatus", loadBalancerStatus);
}
std::string DescribeLoadBalancersRequest::getVpcId()const
{
return vpcId_;

18
slb/src/model/DescribeLoadBalancersResult.cc
View File

@@ -79,14 +79,20 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
loadBalancersObject.resourceGroupId = valueLoadBalancersLoadBalancer["ResourceGroupId"].asString();
if(!valueLoadBalancersLoadBalancer["AddressIPVersion"].isNull())
loadBalancersObject.addressIPVersion = valueLoadBalancersLoadBalancer["AddressIPVersion"].asString();
auto allTagsNode = allLoadBalancersNode["Tags"]["Tag"];
for (auto allLoadBalancersNodeTagsTag : allTagsNode)
if(!valueLoadBalancersLoadBalancer["BusinessStatus"].isNull())
loadBalancersObject.businessStatus = valueLoadBalancersLoadBalancer["BusinessStatus"].asString();
if(!valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].isNull())
loadBalancersObject.modificationProtectionStatus = valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].asString();
if(!valueLoadBalancersLoadBalancer["ModificationProtectionReason"].isNull())
loadBalancersObject.modificationProtectionReason = valueLoadBalancersLoadBalancer["ModificationProtectionReason"].asString();
auto allTagsNode = valueLoadBalancersLoadBalancer["Tags"]["Tag"];
for (auto valueLoadBalancersLoadBalancerTagsTag : allTagsNode)
{
LoadBalancer::Tag tagsObject;
if(!allLoadBalancersNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allLoadBalancersNodeTagsTag["TagKey"].asString();
if(!allLoadBalancersNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allLoadBalancersNodeTagsTag["TagValue"].asString();
if(!valueLoadBalancersLoadBalancerTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueLoadBalancersLoadBalancerTagsTag["TagKey"].asString();
if(!valueLoadBalancersLoadBalancerTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueLoadBalancersLoadBalancerTagsTag["TagValue"].asString();
loadBalancersObject.tags.push_back(tagsObject);
}
loadBalancers_.push_back(loadBalancersObject);

126
slb/src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc
View File

@@ -1,126 +0,0 @@
/*
* 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/DescribeMasterSlaveVServerGroupAttributeRequest.h>
using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupAttributeRequest;
DescribeMasterSlaveVServerGroupAttributeRequest::DescribeMasterSlaveVServerGroupAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroupAttribute")
{}
DescribeMasterSlaveVServerGroupAttributeRequest::~DescribeMasterSlaveVServerGroupAttributeRequest()
{}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getRegionId()const
{
return regionId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
{
masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
setCoreParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getTags()const
{
return tags_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}

87
slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc
View File

@@ -1,87 +0,0 @@
/*
* 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/DescribeMasterSlaveVServerGroupAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult() :
ServiceResult()
{}
DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMasterSlaveVServerGroupAttributeResult::~DescribeMasterSlaveVServerGroupAttributeResult()
{}
void DescribeMasterSlaveVServerGroupAttributeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
{
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].isNull())
masterSlaveBackendServersObject.isBackup = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].isNull())
masterSlaveBackendServersObject.eniHost = valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
if(!value["MasterSlaveVServerGroupName"].isNull())
masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
}
std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
std::vector<DescribeMasterSlaveVServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}
std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const
{
return masterSlaveVServerGroupName_;
}

126
slb/src/model/DescribeMasterSlaveVServerGroupsRequest.cc
View File

@@ -1,126 +0,0 @@
/*
* 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/DescribeMasterSlaveVServerGroupsRequest.h>
using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupsRequest;
DescribeMasterSlaveVServerGroupsRequest::DescribeMasterSlaveVServerGroupsRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroups")
{}
DescribeMasterSlaveVServerGroupsRequest::~DescribeMasterSlaveVServerGroupsRequest()
{}
std::string DescribeMasterSlaveVServerGroupsRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeMasterSlaveVServerGroupsRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeMasterSlaveVServerGroupsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getRegionId()const
{
return regionId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeMasterSlaveVServerGroupsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long DescribeMasterSlaveVServerGroupsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMasterSlaveVServerGroupsRequest::getTags()const
{
return tags_;
}
void DescribeMasterSlaveVServerGroupsRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setCoreParameter("LoadBalancerId", loadBalancerId);
}

59
slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc
View File

@@ -1,59 +0,0 @@
/*
* 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/DescribeMasterSlaveVServerGroupsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult() :
ServiceResult()
{}
DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMasterSlaveVServerGroupsResult::~DescribeMasterSlaveVServerGroupsResult()
{}
void DescribeMasterSlaveVServerGroupsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveVServerGroupsNode = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
for (auto valueMasterSlaveVServerGroupsMasterSlaveVServerGroup : allMasterSlaveVServerGroupsNode)
{
MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
if(!valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupsObject.masterSlaveVServerGroupId = valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupId"].asString();
if(!valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupName"].isNull())
masterSlaveVServerGroupsObject.masterSlaveVServerGroupName = valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupName"].asString();
masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupsObject);
}
}
std::vector<DescribeMasterSlaveVServerGroupsResult::MasterSlaveVServerGroup> DescribeMasterSlaveVServerGroupsResult::getMasterSlaveVServerGroups()const
{
return masterSlaveVServerGroups_;
}

18
slb/src/model/DescribeServerCertificatesResult.cc
View File

@@ -71,14 +71,20 @@ void DescribeServerCertificatesResult::parse(const std::string &payload)
serverCertificatesObject.expireTimeStamp = std::stol(valueServerCertificatesServerCertificate["ExpireTimeStamp"].asString());
if(!valueServerCertificatesServerCertificate["CommonName"].isNull())
serverCertificatesObject.commonName = valueServerCertificatesServerCertificate["CommonName"].asString();
auto allTagsNode = allServerCertificatesNode["Tags"]["Tag"];
for (auto allServerCertificatesNodeTagsTag : allTagsNode)
if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueServerCertificatesServerCertificate["EncryptionKeyLength"].isNull())
serverCertificatesObject.encryptionKeyLength = std::stoi(valueServerCertificatesServerCertificate["EncryptionKeyLength"].asString());
if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
auto allTagsNode = valueServerCertificatesServerCertificate["Tags"]["Tag"];
for (auto valueServerCertificatesServerCertificateTagsTag : allTagsNode)
{
ServerCertificate::Tag tagsObject;
if(!allServerCertificatesNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allServerCertificatesNodeTagsTag["TagKey"].asString();
if(!allServerCertificatesNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allServerCertificatesNodeTagsTag["TagValue"].asString();
if(!valueServerCertificatesServerCertificateTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueServerCertificatesServerCertificateTagsTag["TagKey"].asString();
if(!valueServerCertificatesServerCertificateTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueServerCertificatesServerCertificateTagsTag["TagValue"].asString();
serverCertificatesObject.tags.push_back(tagsObject);
}
auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];

12
slb/src/model/DescribeZonesResult.cc
View File

@@ -47,14 +47,14 @@ void DescribeZonesResult::parse(const std::string &payload)
zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
if(!valueZonesZone["LocalName"].isNull())
zonesObject.localName = valueZonesZone["LocalName"].asString();
auto allSlaveZonesNode = allZonesNode["SlaveZones"]["SlaveZone"];
for (auto allZonesNodeSlaveZonesSlaveZone : allSlaveZonesNode)
auto allSlaveZonesNode = valueZonesZone["SlaveZones"]["SlaveZone"];
for (auto valueZonesZoneSlaveZonesSlaveZone : allSlaveZonesNode)
{
Zone::SlaveZone slaveZonesObject;
if(!allZonesNodeSlaveZonesSlaveZone["ZoneId"].isNull())
slaveZonesObject.zoneId = allZonesNodeSlaveZonesSlaveZone["ZoneId"].asString();
if(!allZonesNodeSlaveZonesSlaveZone["LocalName"].isNull())
slaveZonesObject.localName = allZonesNodeSlaveZonesSlaveZone["LocalName"].asString();
if(!valueZonesZoneSlaveZonesSlaveZone["ZoneId"].isNull())
slaveZonesObject.zoneId = valueZonesZoneSlaveZonesSlaveZone["ZoneId"].asString();
if(!valueZonesZoneSlaveZonesSlaveZone["LocalName"].isNull())
slaveZonesObject.localName = valueZonesZoneSlaveZonesSlaveZone["LocalName"].asString();
zonesObject.slaveZones.push_back(slaveZonesObject);
}
zones_.push_back(zonesObject);

161
slb/src/model/ListTLSCipherPoliciesRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* 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/ListTLSCipherPoliciesRequest.h>
using AlibabaCloud::Slb::Model::ListTLSCipherPoliciesRequest;
ListTLSCipherPoliciesRequest::ListTLSCipherPoliciesRequest() :
RpcServiceRequest("slb", "2014-05-15", "ListTLSCipherPolicies")
{
setMethod(HttpRequest::Method::Post);
}
ListTLSCipherPoliciesRequest::~ListTLSCipherPoliciesRequest()
{}
std::string ListTLSCipherPoliciesRequest::getAccess_key_id()const
{
return access_key_id_;
}
void ListTLSCipherPoliciesRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long ListTLSCipherPoliciesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ListTLSCipherPoliciesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool ListTLSCipherPoliciesRequest::getIncludeListener()const
{
return includeListener_;
}
void ListTLSCipherPoliciesRequest::setIncludeListener(bool includeListener)
{
includeListener_ = includeListener;
setParameter("IncludeListener", includeListener ? "true" : "false");
}
std::string ListTLSCipherPoliciesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ListTLSCipherPoliciesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ListTLSCipherPoliciesRequest::getTLSCipherPolicyId()const
{
return tLSCipherPolicyId_;
}
void ListTLSCipherPoliciesRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
{
tLSCipherPolicyId_ = tLSCipherPolicyId;
setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
}
std::string ListTLSCipherPoliciesRequest::getRegionId()const
{
return regionId_;
}
void ListTLSCipherPoliciesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTLSCipherPoliciesRequest::getNextToken()const
{
return nextToken_;
}
void ListTLSCipherPoliciesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string ListTLSCipherPoliciesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ListTLSCipherPoliciesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ListTLSCipherPoliciesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ListTLSCipherPoliciesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long ListTLSCipherPoliciesRequest::getOwnerId()const
{
return ownerId_;
}
void ListTLSCipherPoliciesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ListTLSCipherPoliciesRequest::getName()const
{
return name_;
}
void ListTLSCipherPoliciesRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int ListTLSCipherPoliciesRequest::getMaxItems()const
{
return maxItems_;
}
void ListTLSCipherPoliciesRequest::setMaxItems(int maxItems)
{
maxItems_ = maxItems;
setParameter("MaxItems", std::to_string(maxItems));
}

102
slb/src/model/ListTLSCipherPoliciesResult.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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/ListTLSCipherPoliciesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
ListTLSCipherPoliciesResult::ListTLSCipherPoliciesResult() :
ServiceResult()
{}
ListTLSCipherPoliciesResult::ListTLSCipherPoliciesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTLSCipherPoliciesResult::~ListTLSCipherPoliciesResult()
{}
void ListTLSCipherPoliciesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTLSCipherPoliciesNode = value["TLSCipherPolicies"]["TLSCipherPolicy"];
for (auto valueTLSCipherPoliciesTLSCipherPolicy : allTLSCipherPoliciesNode)
{
TLSCipherPolicy tLSCipherPoliciesObject;
if(!valueTLSCipherPoliciesTLSCipherPolicy["CreateTime"].isNull())
tLSCipherPoliciesObject.createTime = std::stol(valueTLSCipherPoliciesTLSCipherPolicy["CreateTime"].asString());
if(!valueTLSCipherPoliciesTLSCipherPolicy["InstanceId"].isNull())
tLSCipherPoliciesObject.instanceId = valueTLSCipherPoliciesTLSCipherPolicy["InstanceId"].asString();
if(!valueTLSCipherPoliciesTLSCipherPolicy["Name"].isNull())
tLSCipherPoliciesObject.name = valueTLSCipherPoliciesTLSCipherPolicy["Name"].asString();
if(!valueTLSCipherPoliciesTLSCipherPolicy["Status"].isNull())
tLSCipherPoliciesObject.status = valueTLSCipherPoliciesTLSCipherPolicy["Status"].asString();
auto allRelateListenersNode = valueTLSCipherPoliciesTLSCipherPolicy["RelateListeners"]["RelateListener"];
for (auto valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener : allRelateListenersNode)
{
TLSCipherPolicy::RelateListener relateListenersObject;
if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["LoadBalancerId"].isNull())
relateListenersObject.loadBalancerId = valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["LoadBalancerId"].asString();
if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Port"].isNull())
relateListenersObject.port = std::stoi(valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Port"].asString());
if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Protocol"].isNull())
relateListenersObject.protocol = valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Protocol"].asString();
tLSCipherPoliciesObject.relateListeners.push_back(relateListenersObject);
}
auto allTLSVersions = value["TLSVersions"]["TLSVersion"];
for (auto value : allTLSVersions)
tLSCipherPoliciesObject.tLSVersions.push_back(value.asString());
auto allCiphers = value["Ciphers"]["Cipher"];
for (auto value : allCiphers)
tLSCipherPoliciesObject.ciphers.push_back(value.asString());
tLSCipherPolicies_.push_back(tLSCipherPoliciesObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["IsTruncated"].isNull())
isTruncated_ = value["IsTruncated"].asString() == "true";
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int ListTLSCipherPoliciesResult::getTotalCount()const
{
return totalCount_;
}
std::string ListTLSCipherPoliciesResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListTLSCipherPoliciesResult::TLSCipherPolicy> ListTLSCipherPoliciesResult::getTLSCipherPolicies()const
{
return tLSCipherPolicies_;
}
bool ListTLSCipherPoliciesResult::getIsTruncated()const
{
return isTruncated_;
}

30
slb/src/model/SetDomainExtensionAttributeRequest.cc
View File

@@ -49,6 +49,23 @@ void SetDomainExtensionAttributeRequest::setResourceOwnerId(long resourceOwnerId
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<SetDomainExtensionAttributeRequest::ServerCertificate> SetDomainExtensionAttributeRequest::getServerCertificate()const
{
return serverCertificate_;
}
void SetDomainExtensionAttributeRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
std::string SetDomainExtensionAttributeRequest::getRegionId()const
{
return regionId_;
@@ -93,6 +110,19 @@ void SetDomainExtensionAttributeRequest::setOwnerAccount(const std::string& owne
setParameter("OwnerAccount", ownerAccount);
}
std::vector<std::string> SetDomainExtensionAttributeRequest::getCertificateId()const
{
return certificateId_;
}
void SetDomainExtensionAttributeRequest::setCertificateId(const std::vector<std::string>& certificateId)
{
certificateId_ = certificateId;
for(int dep1 = 0; dep1!= certificateId.size(); dep1++) {
setParameter("CertificateId."+ std::to_string(dep1), certificateId.at(dep1));
}
}
long SetDomainExtensionAttributeRequest::getOwnerId()const
{
return ownerId_;

17
slb/src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc
View File

@@ -38,6 +38,23 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerId(long resou
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<SetLoadBalancerHTTPSListenerAttributeRequest::ServerCertificate> SetLoadBalancerHTTPSListenerAttributeRequest::getServerCertificate()const
{
return serverCertificate_;
}
void SetLoadBalancerHTTPSListenerAttributeRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckTimeout()const
{
return healthCheckTimeout_;

89
slb/src/model/SetLoadBalancerListenerAttributeExRequest.cc
View File

@@ -1,89 +0,0 @@
/*
* 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/SetLoadBalancerListenerAttributeExRequest.h>
using AlibabaCloud::Slb::Model::SetLoadBalancerListenerAttributeExRequest;
SetLoadBalancerListenerAttributeExRequest::SetLoadBalancerListenerAttributeExRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerListenerAttributeEx")
{
setMethod(HttpRequest::Method::Post);
}
SetLoadBalancerListenerAttributeExRequest::~SetLoadBalancerListenerAttributeExRequest()
{}
int SetLoadBalancerListenerAttributeExRequest::getListenerPort()const
{
return listenerPort_;
}
void SetLoadBalancerListenerAttributeExRequest::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
setParameter("ListenerPort", std::to_string(listenerPort));
}
std::vector<SetLoadBalancerListenerAttributeExRequest::KvAttribute> SetLoadBalancerListenerAttributeExRequest::getKvAttribute()const
{
return kvAttribute_;
}
void SetLoadBalancerListenerAttributeExRequest::setKvAttribute(const std::vector<KvAttribute>& kvAttribute)
{
kvAttribute_ = kvAttribute;
for(int dep1 = 0; dep1!= kvAttribute.size(); dep1++) {
auto kvAttributeObj = kvAttribute.at(dep1);
std::string kvAttributeObjStr = "KvAttribute." + std::to_string(dep1 + 1);
setParameter(kvAttributeObjStr + ".Value", kvAttributeObj.value);
setParameter(kvAttributeObjStr + ".Key", kvAttributeObj.key);
}
}
std::string SetLoadBalancerListenerAttributeExRequest::getProtocol()const
{
return protocol_;
}
void SetLoadBalancerListenerAttributeExRequest::setProtocol(const std::string& protocol)
{
protocol_ = protocol;
setParameter("Protocol", protocol);
}
std::string SetLoadBalancerListenerAttributeExRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void SetLoadBalancerListenerAttributeExRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string SetLoadBalancerListenerAttributeExRequest::getRegionId()const
{
return regionId_;
}
void SetLoadBalancerListenerAttributeExRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

117
slb/src/model/SetLoadBalancerModificationProtectionRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/SetLoadBalancerModificationProtectionRequest.h>
using AlibabaCloud::Slb::Model::SetLoadBalancerModificationProtectionRequest;
SetLoadBalancerModificationProtectionRequest::SetLoadBalancerModificationProtectionRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerModificationProtection")
{
setMethod(HttpRequest::Method::Post);
}
SetLoadBalancerModificationProtectionRequest::~SetLoadBalancerModificationProtectionRequest()
{}
std::string SetLoadBalancerModificationProtectionRequest::getModificationProtectionReason()const
{
return modificationProtectionReason_;
}
void SetLoadBalancerModificationProtectionRequest::setModificationProtectionReason(const std::string& modificationProtectionReason)
{
modificationProtectionReason_ = modificationProtectionReason;
setParameter("ModificationProtectionReason", modificationProtectionReason);
}
long SetLoadBalancerModificationProtectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void SetLoadBalancerModificationProtectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string SetLoadBalancerModificationProtectionRequest::getRegionId()const
{
return regionId_;
}
void SetLoadBalancerModificationProtectionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string SetLoadBalancerModificationProtectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void SetLoadBalancerModificationProtectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string SetLoadBalancerModificationProtectionRequest::getModificationProtectionStatus()const
{
return modificationProtectionStatus_;
}
void SetLoadBalancerModificationProtectionRequest::setModificationProtectionStatus(const std::string& modificationProtectionStatus)
{
modificationProtectionStatus_ = modificationProtectionStatus;
setParameter("ModificationProtectionStatus", modificationProtectionStatus);
}
std::string SetLoadBalancerModificationProtectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void SetLoadBalancerModificationProtectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long SetLoadBalancerModificationProtectionRequest::getOwnerId()const
{
return ownerId_;
}
void SetLoadBalancerModificationProtectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetLoadBalancerModificationProtectionRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void SetLoadBalancerModificationProtectionRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}

10
slb/src/model/SetLoadBalancerListenerAttributeExResult.cc → slb/src/model/SetLoadBalancerModificationProtectionResult.cc
View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h>
#include <alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
SetLoadBalancerListenerAttributeExResult::SetLoadBalancerListenerAttributeExResult() :
SetLoadBalancerModificationProtectionResult::SetLoadBalancerModificationProtectionResult() :
ServiceResult()
{}
SetLoadBalancerListenerAttributeExResult::SetLoadBalancerListenerAttributeExResult(const std::string &payload) :
SetLoadBalancerModificationProtectionResult::SetLoadBalancerModificationProtectionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetLoadBalancerListenerAttributeExResult::~SetLoadBalancerListenerAttributeExResult()
SetLoadBalancerModificationProtectionResult::~SetLoadBalancerModificationProtectionResult()
{}
void SetLoadBalancerListenerAttributeExResult::parse(const std::string &payload)
void SetLoadBalancerModificationProtectionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;

154
slb/src/model/SetTLSCipherPolicyAttributeRequest.cc Normal file
View File

@@ -0,0 +1,154 @@
/*
* 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/SetTLSCipherPolicyAttributeRequest.h>
using AlibabaCloud::Slb::Model::SetTLSCipherPolicyAttributeRequest;
SetTLSCipherPolicyAttributeRequest::SetTLSCipherPolicyAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetTLSCipherPolicyAttribute")
{
setMethod(HttpRequest::Method::Post);
}
SetTLSCipherPolicyAttributeRequest::~SetTLSCipherPolicyAttributeRequest()
{}
std::string SetTLSCipherPolicyAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void SetTLSCipherPolicyAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long SetTLSCipherPolicyAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void SetTLSCipherPolicyAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string SetTLSCipherPolicyAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetTLSCipherPolicyAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string SetTLSCipherPolicyAttributeRequest::getTLSCipherPolicyId()const
{
return tLSCipherPolicyId_;
}
void SetTLSCipherPolicyAttributeRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
{
tLSCipherPolicyId_ = tLSCipherPolicyId;
setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
}
std::string SetTLSCipherPolicyAttributeRequest::getRegionId()const
{
return regionId_;
}
void SetTLSCipherPolicyAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<std::string> SetTLSCipherPolicyAttributeRequest::getCiphers()const
{
return ciphers_;
}
void SetTLSCipherPolicyAttributeRequest::setCiphers(const std::vector<std::string>& ciphers)
{
ciphers_ = ciphers;
for(int dep1 = 0; dep1!= ciphers.size(); dep1++) {
setParameter("Ciphers."+ std::to_string(dep1), ciphers.at(dep1));
}
}
std::vector<std::string> SetTLSCipherPolicyAttributeRequest::getTLSVersions()const
{
return tLSVersions_;
}
void SetTLSCipherPolicyAttributeRequest::setTLSVersions(const std::vector<std::string>& tLSVersions)
{
tLSVersions_ = tLSVersions;
for(int dep1 = 0; dep1!= tLSVersions.size(); dep1++) {
setParameter("TLSVersions."+ std::to_string(dep1), tLSVersions.at(dep1));
}
}
std::string SetTLSCipherPolicyAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void SetTLSCipherPolicyAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string SetTLSCipherPolicyAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void SetTLSCipherPolicyAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long SetTLSCipherPolicyAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void SetTLSCipherPolicyAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetTLSCipherPolicyAttributeRequest::getName()const
{
return name_;
}
void SetTLSCipherPolicyAttributeRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
slb/src/model/SetTLSCipherPolicyAttributeResult.cc Normal file
View File

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

11
slb/src/model/UploadCACertificateRequest.cc
View File

@@ -115,6 +115,17 @@ void UploadCACertificateRequest::setOwnerAccount(const std::string& ownerAccount
setParameter("OwnerAccount", ownerAccount);
}
std::string UploadCACertificateRequest::getStandardType()const
{
return standardType_;
}
void UploadCACertificateRequest::setStandardType(const std::string& standardType)
{
standardType_ = standardType;
setParameter("StandardType", standardType);
}
long UploadCACertificateRequest::getOwnerId()const
{
return ownerId_;

11
slb/src/model/UploadServerCertificateRequest.cc
View File

@@ -137,6 +137,17 @@ void UploadServerCertificateRequest::setOwnerAccount(const std::string& ownerAcc
setParameter("OwnerAccount", ownerAccount);
}
std::string UploadServerCertificateRequest::getStandardType()const
{
return standardType_;
}
void UploadServerCertificateRequest::setStandardType(const std::string& standardType)
{
standardType_ = standardType;
setParameter("StandardType", standardType);
}
long UploadServerCertificateRequest::getOwnerId()const
{
return ownerId_;