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

Add ListDashboardUrl api.

Browse Source
This commit is contained in:
sdk-team
2022-05-13 12:53:12 +00:00
parent a514d1586b
commit 5706cda196
169 changed files with 6451 additions and 1710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2022-05-13 Version: 1.36.1125
- Add ListDashboardUrl api.
2022-05-11 Version: 1.36.1124
- Update by sdk platform.

2
VERSION
View File

@@ -1 +1 @@
1.36.1124
1.36.1125

108
mse/CMakeLists.txt
View File

@@ -39,16 +39,20 @@ set(mse_public_header_model
include/alibabacloud/mse/model/AddMockRuleResult.h
include/alibabacloud/mse/model/AddSSLCertRequest.h
include/alibabacloud/mse/model/AddSSLCertResult.h
include/alibabacloud/mse/model/AddSeataServerRequest.h
include/alibabacloud/mse/model/AddSeataServerResult.h
include/alibabacloud/mse/model/AddSecurityGroupRuleRequest.h
include/alibabacloud/mse/model/AddSecurityGroupRuleResult.h
include/alibabacloud/mse/model/AddServiceSourceRequest.h
include/alibabacloud/mse/model/AddServiceSourceResult.h
include/alibabacloud/mse/model/AddTestRequest.h
include/alibabacloud/mse/model/AddTestResult.h
include/alibabacloud/mse/model/ApplyGatewayRouteRequest.h
include/alibabacloud/mse/model/ApplyGatewayRouteResult.h
include/alibabacloud/mse/model/ApplyTagPoliciesRequest.h
include/alibabacloud/mse/model/ApplyTagPoliciesResult.h
include/alibabacloud/mse/model/CloneNacosConfigRequest.h
include/alibabacloud/mse/model/CloneNacosConfigResult.h
include/alibabacloud/mse/model/CreateAlarmRuleRequest.h
include/alibabacloud/mse/model/CreateAlarmRuleResult.h
include/alibabacloud/mse/model/CreateApplicationRequest.h
include/alibabacloud/mse/model/CreateApplicationResult.h
include/alibabacloud/mse/model/CreateClusterRequest.h
@@ -65,10 +69,10 @@ set(mse_public_header_model
include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneResult.h
include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupRequest.h
include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupResult.h
include/alibabacloud/mse/model/CreateVGroupRequest.h
include/alibabacloud/mse/model/CreateVGroupResult.h
include/alibabacloud/mse/model/CreateZnodeRequest.h
include/alibabacloud/mse/model/CreateZnodeResult.h
include/alibabacloud/mse/model/DeleteAlarmRuleRequest.h
include/alibabacloud/mse/model/DeleteAlarmRuleResult.h
include/alibabacloud/mse/model/DeleteAuthResourceRequest.h
include/alibabacloud/mse/model/DeleteAuthResourceResult.h
include/alibabacloud/mse/model/DeleteClusterRequest.h
@@ -81,6 +85,8 @@ set(mse_public_header_model
include/alibabacloud/mse/model/DeleteGatewayDomainResult.h
include/alibabacloud/mse/model/DeleteGatewayRouteRequest.h
include/alibabacloud/mse/model/DeleteGatewayRouteResult.h
include/alibabacloud/mse/model/DeleteGatewayServiceRequest.h
include/alibabacloud/mse/model/DeleteGatewayServiceResult.h
include/alibabacloud/mse/model/DeleteGatewayServiceVersionRequest.h
include/alibabacloud/mse/model/DeleteGatewayServiceVersionResult.h
include/alibabacloud/mse/model/DeleteGatewaySlbRequest.h
@@ -93,18 +99,30 @@ set(mse_public_header_model
include/alibabacloud/mse/model/DeleteNacosInstanceResult.h
include/alibabacloud/mse/model/DeleteNacosServiceRequest.h
include/alibabacloud/mse/model/DeleteNacosServiceResult.h
include/alibabacloud/mse/model/DeleteSeataServerRequest.h
include/alibabacloud/mse/model/DeleteSeataServerResult.h
include/alibabacloud/mse/model/DeleteSecurityGroupRuleRequest.h
include/alibabacloud/mse/model/DeleteSecurityGroupRuleResult.h
include/alibabacloud/mse/model/DeleteServiceSourceRequest.h
include/alibabacloud/mse/model/DeleteServiceSourceResult.h
include/alibabacloud/mse/model/DeleteSwimmingLaneRequest.h
include/alibabacloud/mse/model/DeleteSwimmingLaneResult.h
include/alibabacloud/mse/model/DeleteSwimmingLaneGroupRequest.h
include/alibabacloud/mse/model/DeleteSwimmingLaneGroupResult.h
include/alibabacloud/mse/model/DeleteVGroupRequest.h
include/alibabacloud/mse/model/DeleteVGroupResult.h
include/alibabacloud/mse/model/DeleteZnodeRequest.h
include/alibabacloud/mse/model/DeleteZnodeResult.h
include/alibabacloud/mse/model/ExportNacosConfigRequest.h
include/alibabacloud/mse/model/ExportNacosConfigResult.h
include/alibabacloud/mse/model/GetAppMessageQueueRouteRequest.h
include/alibabacloud/mse/model/GetAppMessageQueueRouteResult.h
include/alibabacloud/mse/model/GetApplicationListRequest.h
include/alibabacloud/mse/model/GetApplicationListResult.h
include/alibabacloud/mse/model/GetBlackWhiteListRequest.h
include/alibabacloud/mse/model/GetBlackWhiteListResult.h
include/alibabacloud/mse/model/GetDashBoardUrlRequest.h
include/alibabacloud/mse/model/GetDashBoardUrlResult.h
include/alibabacloud/mse/model/GetEngineNamepaceRequest.h
include/alibabacloud/mse/model/GetEngineNamepaceResult.h
include/alibabacloud/mse/model/GetGatewayRequest.h
@@ -145,14 +163,6 @@ set(mse_public_header_model
include/alibabacloud/mse/model/ImportNacosConfigResult.h
include/alibabacloud/mse/model/ImportServicesRequest.h
include/alibabacloud/mse/model/ImportServicesResult.h
include/alibabacloud/mse/model/ListAlarmContactGroupsRequest.h
include/alibabacloud/mse/model/ListAlarmContactGroupsResult.h
include/alibabacloud/mse/model/ListAlarmHistoriesRequest.h
include/alibabacloud/mse/model/ListAlarmHistoriesResult.h
include/alibabacloud/mse/model/ListAlarmItemsRequest.h
include/alibabacloud/mse/model/ListAlarmItemsResult.h
include/alibabacloud/mse/model/ListAlarmRulesRequest.h
include/alibabacloud/mse/model/ListAlarmRulesResult.h
include/alibabacloud/mse/model/ListAnsInstancesRequest.h
include/alibabacloud/mse/model/ListAnsInstancesResult.h
include/alibabacloud/mse/model/ListAnsServiceClustersRequest.h
@@ -165,6 +175,8 @@ set(mse_public_header_model
include/alibabacloud/mse/model/ListApplicationsWithTagRulesResult.h
include/alibabacloud/mse/model/ListClusterConnectionTypesRequest.h
include/alibabacloud/mse/model/ListClusterConnectionTypesResult.h
include/alibabacloud/mse/model/ListClusterDetailFeatureRequest.h
include/alibabacloud/mse/model/ListClusterDetailFeatureResult.h
include/alibabacloud/mse/model/ListClusterTypesRequest.h
include/alibabacloud/mse/model/ListClusterTypesResult.h
include/alibabacloud/mse/model/ListClusterVersionsRequest.h
@@ -187,6 +199,8 @@ set(mse_public_header_model
include/alibabacloud/mse/model/ListGatewayServiceResult.h
include/alibabacloud/mse/model/ListGatewaySlbRequest.h
include/alibabacloud/mse/model/ListGatewaySlbResult.h
include/alibabacloud/mse/model/ListInstancesRequest.h
include/alibabacloud/mse/model/ListInstancesResult.h
include/alibabacloud/mse/model/ListListenersByConfigRequest.h
include/alibabacloud/mse/model/ListListenersByConfigResult.h
include/alibabacloud/mse/model/ListListenersByIpRequest.h
@@ -197,6 +211,10 @@ set(mse_public_header_model
include/alibabacloud/mse/model/ListNacosHistoryConfigsResult.h
include/alibabacloud/mse/model/ListSSLCertRequest.h
include/alibabacloud/mse/model/ListSSLCertResult.h
include/alibabacloud/mse/model/ListSecurityGroupRequest.h
include/alibabacloud/mse/model/ListSecurityGroupResult.h
include/alibabacloud/mse/model/ListSecurityGroupRuleRequest.h
include/alibabacloud/mse/model/ListSecurityGroupRuleResult.h
include/alibabacloud/mse/model/ListServiceSourceRequest.h
include/alibabacloud/mse/model/ListServiceSourceResult.h
include/alibabacloud/mse/model/ListZnodeChildrenRequest.h
@@ -233,14 +251,16 @@ set(mse_public_header_model
include/alibabacloud/mse/model/QuerySlbSpecResult.h
include/alibabacloud/mse/model/QuerySwimmingLaneByIdRequest.h
include/alibabacloud/mse/model/QuerySwimmingLaneByIdResult.h
include/alibabacloud/mse/model/QueryUserVpcRequest.h
include/alibabacloud/mse/model/QueryUserVpcResult.h
include/alibabacloud/mse/model/QueryZnodeDetailRequest.h
include/alibabacloud/mse/model/QueryZnodeDetailResult.h
include/alibabacloud/mse/model/RestartClusterRequest.h
include/alibabacloud/mse/model/RestartClusterResult.h
include/alibabacloud/mse/model/RestartSeataServerRequest.h
include/alibabacloud/mse/model/RestartSeataServerResult.h
include/alibabacloud/mse/model/RetryClusterRequest.h
include/alibabacloud/mse/model/RetryClusterResult.h
include/alibabacloud/mse/model/ScalingClusterRequest.h
include/alibabacloud/mse/model/ScalingClusterResult.h
include/alibabacloud/mse/model/SelectGatewaySlbRequest.h
include/alibabacloud/mse/model/SelectGatewaySlbResult.h
include/alibabacloud/mse/model/UpdateAclRequest.h
@@ -271,10 +291,16 @@ set(mse_public_header_model
include/alibabacloud/mse/model/UpdateGatewayRouteRetryResult.h
include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutRequest.h
include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutResult.h
include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusRequest.h
include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusResult.h
include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyRequest.h
include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyResult.h
include/alibabacloud/mse/model/UpdateGatewayServiceVersionRequest.h
include/alibabacloud/mse/model/UpdateGatewayServiceVersionResult.h
include/alibabacloud/mse/model/UpdateImageRequest.h
include/alibabacloud/mse/model/UpdateImageResult.h
include/alibabacloud/mse/model/UpdateMessageQueueRouteRequest.h
include/alibabacloud/mse/model/UpdateMessageQueueRouteResult.h
include/alibabacloud/mse/model/UpdateNacosClusterRequest.h
include/alibabacloud/mse/model/UpdateNacosClusterResult.h
include/alibabacloud/mse/model/UpdateNacosConfigRequest.h
@@ -310,16 +336,20 @@ set(mse_src
src/model/AddMockRuleResult.cc
src/model/AddSSLCertRequest.cc
src/model/AddSSLCertResult.cc
src/model/AddSeataServerRequest.cc
src/model/AddSeataServerResult.cc
src/model/AddSecurityGroupRuleRequest.cc
src/model/AddSecurityGroupRuleResult.cc
src/model/AddServiceSourceRequest.cc
src/model/AddServiceSourceResult.cc
src/model/AddTestRequest.cc
src/model/AddTestResult.cc
src/model/ApplyGatewayRouteRequest.cc
src/model/ApplyGatewayRouteResult.cc
src/model/ApplyTagPoliciesRequest.cc
src/model/ApplyTagPoliciesResult.cc
src/model/CloneNacosConfigRequest.cc
src/model/CloneNacosConfigResult.cc
src/model/CreateAlarmRuleRequest.cc
src/model/CreateAlarmRuleResult.cc
src/model/CreateApplicationRequest.cc
src/model/CreateApplicationResult.cc
src/model/CreateClusterRequest.cc
@@ -336,10 +366,10 @@ set(mse_src
src/model/CreateOrUpdateSwimmingLaneResult.cc
src/model/CreateOrUpdateSwimmingLaneGroupRequest.cc
src/model/CreateOrUpdateSwimmingLaneGroupResult.cc
src/model/CreateVGroupRequest.cc
src/model/CreateVGroupResult.cc
src/model/CreateZnodeRequest.cc
src/model/CreateZnodeResult.cc
src/model/DeleteAlarmRuleRequest.cc
src/model/DeleteAlarmRuleResult.cc
src/model/DeleteAuthResourceRequest.cc
src/model/DeleteAuthResourceResult.cc
src/model/DeleteClusterRequest.cc
@@ -352,6 +382,8 @@ set(mse_src
src/model/DeleteGatewayDomainResult.cc
src/model/DeleteGatewayRouteRequest.cc
src/model/DeleteGatewayRouteResult.cc
src/model/DeleteGatewayServiceRequest.cc
src/model/DeleteGatewayServiceResult.cc
src/model/DeleteGatewayServiceVersionRequest.cc
src/model/DeleteGatewayServiceVersionResult.cc
src/model/DeleteGatewaySlbRequest.cc
@@ -364,18 +396,30 @@ set(mse_src
src/model/DeleteNacosInstanceResult.cc
src/model/DeleteNacosServiceRequest.cc
src/model/DeleteNacosServiceResult.cc
src/model/DeleteSeataServerRequest.cc
src/model/DeleteSeataServerResult.cc
src/model/DeleteSecurityGroupRuleRequest.cc
src/model/DeleteSecurityGroupRuleResult.cc
src/model/DeleteServiceSourceRequest.cc
src/model/DeleteServiceSourceResult.cc
src/model/DeleteSwimmingLaneRequest.cc
src/model/DeleteSwimmingLaneResult.cc
src/model/DeleteSwimmingLaneGroupRequest.cc
src/model/DeleteSwimmingLaneGroupResult.cc
src/model/DeleteVGroupRequest.cc
src/model/DeleteVGroupResult.cc
src/model/DeleteZnodeRequest.cc
src/model/DeleteZnodeResult.cc
src/model/ExportNacosConfigRequest.cc
src/model/ExportNacosConfigResult.cc
src/model/GetAppMessageQueueRouteRequest.cc
src/model/GetAppMessageQueueRouteResult.cc
src/model/GetApplicationListRequest.cc
src/model/GetApplicationListResult.cc
src/model/GetBlackWhiteListRequest.cc
src/model/GetBlackWhiteListResult.cc
src/model/GetDashBoardUrlRequest.cc
src/model/GetDashBoardUrlResult.cc
src/model/GetEngineNamepaceRequest.cc
src/model/GetEngineNamepaceResult.cc
src/model/GetGatewayRequest.cc
@@ -416,14 +460,6 @@ set(mse_src
src/model/ImportNacosConfigResult.cc
src/model/ImportServicesRequest.cc
src/model/ImportServicesResult.cc
src/model/ListAlarmContactGroupsRequest.cc
src/model/ListAlarmContactGroupsResult.cc
src/model/ListAlarmHistoriesRequest.cc
src/model/ListAlarmHistoriesResult.cc
src/model/ListAlarmItemsRequest.cc
src/model/ListAlarmItemsResult.cc
src/model/ListAlarmRulesRequest.cc
src/model/ListAlarmRulesResult.cc
src/model/ListAnsInstancesRequest.cc
src/model/ListAnsInstancesResult.cc
src/model/ListAnsServiceClustersRequest.cc
@@ -436,6 +472,8 @@ set(mse_src
src/model/ListApplicationsWithTagRulesResult.cc
src/model/ListClusterConnectionTypesRequest.cc
src/model/ListClusterConnectionTypesResult.cc
src/model/ListClusterDetailFeatureRequest.cc
src/model/ListClusterDetailFeatureResult.cc
src/model/ListClusterTypesRequest.cc
src/model/ListClusterTypesResult.cc
src/model/ListClusterVersionsRequest.cc
@@ -458,6 +496,8 @@ set(mse_src
src/model/ListGatewayServiceResult.cc
src/model/ListGatewaySlbRequest.cc
src/model/ListGatewaySlbResult.cc
src/model/ListInstancesRequest.cc
src/model/ListInstancesResult.cc
src/model/ListListenersByConfigRequest.cc
src/model/ListListenersByConfigResult.cc
src/model/ListListenersByIpRequest.cc
@@ -468,6 +508,10 @@ set(mse_src
src/model/ListNacosHistoryConfigsResult.cc
src/model/ListSSLCertRequest.cc
src/model/ListSSLCertResult.cc
src/model/ListSecurityGroupRequest.cc
src/model/ListSecurityGroupResult.cc
src/model/ListSecurityGroupRuleRequest.cc
src/model/ListSecurityGroupRuleResult.cc
src/model/ListServiceSourceRequest.cc
src/model/ListServiceSourceResult.cc
src/model/ListZnodeChildrenRequest.cc
@@ -504,14 +548,16 @@ set(mse_src
src/model/QuerySlbSpecResult.cc
src/model/QuerySwimmingLaneByIdRequest.cc
src/model/QuerySwimmingLaneByIdResult.cc
src/model/QueryUserVpcRequest.cc
src/model/QueryUserVpcResult.cc
src/model/QueryZnodeDetailRequest.cc
src/model/QueryZnodeDetailResult.cc
src/model/RestartClusterRequest.cc
src/model/RestartClusterResult.cc
src/model/RestartSeataServerRequest.cc
src/model/RestartSeataServerResult.cc
src/model/RetryClusterRequest.cc
src/model/RetryClusterResult.cc
src/model/ScalingClusterRequest.cc
src/model/ScalingClusterResult.cc
src/model/SelectGatewaySlbRequest.cc
src/model/SelectGatewaySlbResult.cc
src/model/UpdateAclRequest.cc
@@ -542,10 +588,16 @@ set(mse_src
src/model/UpdateGatewayRouteRetryResult.cc
src/model/UpdateGatewayRouteTimeoutRequest.cc
src/model/UpdateGatewayRouteTimeoutResult.cc
src/model/UpdateGatewayRouteWafStatusRequest.cc
src/model/UpdateGatewayRouteWafStatusResult.cc
src/model/UpdateGatewayServiceTrafficPolicyRequest.cc
src/model/UpdateGatewayServiceTrafficPolicyResult.cc
src/model/UpdateGatewayServiceVersionRequest.cc
src/model/UpdateGatewayServiceVersionResult.cc
src/model/UpdateImageRequest.cc
src/model/UpdateImageResult.cc
src/model/UpdateMessageQueueRouteRequest.cc
src/model/UpdateMessageQueueRouteResult.cc
src/model/UpdateNacosClusterRequest.cc
src/model/UpdateNacosClusterResult.cc
src/model/UpdateNacosConfigRequest.cc

216
mse/include/alibabacloud/mse/MseClient.h
View File

@@ -40,16 +40,20 @@
#include "model/AddMockRuleResult.h"
#include "model/AddSSLCertRequest.h"
#include "model/AddSSLCertResult.h"
#include "model/AddSeataServerRequest.h"
#include "model/AddSeataServerResult.h"
#include "model/AddSecurityGroupRuleRequest.h"
#include "model/AddSecurityGroupRuleResult.h"
#include "model/AddServiceSourceRequest.h"
#include "model/AddServiceSourceResult.h"
#include "model/AddTestRequest.h"
#include "model/AddTestResult.h"
#include "model/ApplyGatewayRouteRequest.h"
#include "model/ApplyGatewayRouteResult.h"
#include "model/ApplyTagPoliciesRequest.h"
#include "model/ApplyTagPoliciesResult.h"
#include "model/CloneNacosConfigRequest.h"
#include "model/CloneNacosConfigResult.h"
#include "model/CreateAlarmRuleRequest.h"
#include "model/CreateAlarmRuleResult.h"
#include "model/CreateApplicationRequest.h"
#include "model/CreateApplicationResult.h"
#include "model/CreateClusterRequest.h"
@@ -66,10 +70,10 @@
#include "model/CreateOrUpdateSwimmingLaneResult.h"
#include "model/CreateOrUpdateSwimmingLaneGroupRequest.h"
#include "model/CreateOrUpdateSwimmingLaneGroupResult.h"
#include "model/CreateVGroupRequest.h"
#include "model/CreateVGroupResult.h"
#include "model/CreateZnodeRequest.h"
#include "model/CreateZnodeResult.h"
#include "model/DeleteAlarmRuleRequest.h"
#include "model/DeleteAlarmRuleResult.h"
#include "model/DeleteAuthResourceRequest.h"
#include "model/DeleteAuthResourceResult.h"
#include "model/DeleteClusterRequest.h"
@@ -82,6 +86,8 @@
#include "model/DeleteGatewayDomainResult.h"
#include "model/DeleteGatewayRouteRequest.h"
#include "model/DeleteGatewayRouteResult.h"
#include "model/DeleteGatewayServiceRequest.h"
#include "model/DeleteGatewayServiceResult.h"
#include "model/DeleteGatewayServiceVersionRequest.h"
#include "model/DeleteGatewayServiceVersionResult.h"
#include "model/DeleteGatewaySlbRequest.h"
@@ -94,18 +100,30 @@
#include "model/DeleteNacosInstanceResult.h"
#include "model/DeleteNacosServiceRequest.h"
#include "model/DeleteNacosServiceResult.h"
#include "model/DeleteSeataServerRequest.h"
#include "model/DeleteSeataServerResult.h"
#include "model/DeleteSecurityGroupRuleRequest.h"
#include "model/DeleteSecurityGroupRuleResult.h"
#include "model/DeleteServiceSourceRequest.h"
#include "model/DeleteServiceSourceResult.h"
#include "model/DeleteSwimmingLaneRequest.h"
#include "model/DeleteSwimmingLaneResult.h"
#include "model/DeleteSwimmingLaneGroupRequest.h"
#include "model/DeleteSwimmingLaneGroupResult.h"
#include "model/DeleteVGroupRequest.h"
#include "model/DeleteVGroupResult.h"
#include "model/DeleteZnodeRequest.h"
#include "model/DeleteZnodeResult.h"
#include "model/ExportNacosConfigRequest.h"
#include "model/ExportNacosConfigResult.h"
#include "model/GetAppMessageQueueRouteRequest.h"
#include "model/GetAppMessageQueueRouteResult.h"
#include "model/GetApplicationListRequest.h"
#include "model/GetApplicationListResult.h"
#include "model/GetBlackWhiteListRequest.h"
#include "model/GetBlackWhiteListResult.h"
#include "model/GetDashBoardUrlRequest.h"
#include "model/GetDashBoardUrlResult.h"
#include "model/GetEngineNamepaceRequest.h"
#include "model/GetEngineNamepaceResult.h"
#include "model/GetGatewayRequest.h"
@@ -146,14 +164,6 @@
#include "model/ImportNacosConfigResult.h"
#include "model/ImportServicesRequest.h"
#include "model/ImportServicesResult.h"
#include "model/ListAlarmContactGroupsRequest.h"
#include "model/ListAlarmContactGroupsResult.h"
#include "model/ListAlarmHistoriesRequest.h"
#include "model/ListAlarmHistoriesResult.h"
#include "model/ListAlarmItemsRequest.h"
#include "model/ListAlarmItemsResult.h"
#include "model/ListAlarmRulesRequest.h"
#include "model/ListAlarmRulesResult.h"
#include "model/ListAnsInstancesRequest.h"
#include "model/ListAnsInstancesResult.h"
#include "model/ListAnsServiceClustersRequest.h"
@@ -166,6 +176,8 @@
#include "model/ListApplicationsWithTagRulesResult.h"
#include "model/ListClusterConnectionTypesRequest.h"
#include "model/ListClusterConnectionTypesResult.h"
#include "model/ListClusterDetailFeatureRequest.h"
#include "model/ListClusterDetailFeatureResult.h"
#include "model/ListClusterTypesRequest.h"
#include "model/ListClusterTypesResult.h"
#include "model/ListClusterVersionsRequest.h"
@@ -188,6 +200,8 @@
#include "model/ListGatewayServiceResult.h"
#include "model/ListGatewaySlbRequest.h"
#include "model/ListGatewaySlbResult.h"
#include "model/ListInstancesRequest.h"
#include "model/ListInstancesResult.h"
#include "model/ListListenersByConfigRequest.h"
#include "model/ListListenersByConfigResult.h"
#include "model/ListListenersByIpRequest.h"
@@ -198,6 +212,10 @@
#include "model/ListNacosHistoryConfigsResult.h"
#include "model/ListSSLCertRequest.h"
#include "model/ListSSLCertResult.h"
#include "model/ListSecurityGroupRequest.h"
#include "model/ListSecurityGroupResult.h"
#include "model/ListSecurityGroupRuleRequest.h"
#include "model/ListSecurityGroupRuleResult.h"
#include "model/ListServiceSourceRequest.h"
#include "model/ListServiceSourceResult.h"
#include "model/ListZnodeChildrenRequest.h"
@@ -234,14 +252,16 @@
#include "model/QuerySlbSpecResult.h"
#include "model/QuerySwimmingLaneByIdRequest.h"
#include "model/QuerySwimmingLaneByIdResult.h"
#include "model/QueryUserVpcRequest.h"
#include "model/QueryUserVpcResult.h"
#include "model/QueryZnodeDetailRequest.h"
#include "model/QueryZnodeDetailResult.h"
#include "model/RestartClusterRequest.h"
#include "model/RestartClusterResult.h"
#include "model/RestartSeataServerRequest.h"
#include "model/RestartSeataServerResult.h"
#include "model/RetryClusterRequest.h"
#include "model/RetryClusterResult.h"
#include "model/ScalingClusterRequest.h"
#include "model/ScalingClusterResult.h"
#include "model/SelectGatewaySlbRequest.h"
#include "model/SelectGatewaySlbResult.h"
#include "model/UpdateAclRequest.h"
@@ -272,10 +292,16 @@
#include "model/UpdateGatewayRouteRetryResult.h"
#include "model/UpdateGatewayRouteTimeoutRequest.h"
#include "model/UpdateGatewayRouteTimeoutResult.h"
#include "model/UpdateGatewayRouteWafStatusRequest.h"
#include "model/UpdateGatewayRouteWafStatusResult.h"
#include "model/UpdateGatewayServiceTrafficPolicyRequest.h"
#include "model/UpdateGatewayServiceTrafficPolicyResult.h"
#include "model/UpdateGatewayServiceVersionRequest.h"
#include "model/UpdateGatewayServiceVersionResult.h"
#include "model/UpdateImageRequest.h"
#include "model/UpdateImageResult.h"
#include "model/UpdateMessageQueueRouteRequest.h"
#include "model/UpdateMessageQueueRouteResult.h"
#include "model/UpdateNacosClusterRequest.h"
#include "model/UpdateNacosClusterResult.h"
#include "model/UpdateNacosConfigRequest.h"
@@ -326,9 +352,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AddSSLCertResult> AddSSLCertOutcome;
typedef std::future<AddSSLCertOutcome> AddSSLCertOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::AddSSLCertRequest&, const AddSSLCertOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSSLCertAsyncHandler;
typedef Outcome<Error, Model::AddSeataServerResult> AddSeataServerOutcome;
typedef std::future<AddSeataServerOutcome> AddSeataServerOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::AddSeataServerRequest&, const AddSeataServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSeataServerAsyncHandler;
typedef Outcome<Error, Model::AddSecurityGroupRuleResult> AddSecurityGroupRuleOutcome;
typedef std::future<AddSecurityGroupRuleOutcome> AddSecurityGroupRuleOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::AddSecurityGroupRuleRequest&, const AddSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSecurityGroupRuleAsyncHandler;
typedef Outcome<Error, Model::AddServiceSourceResult> AddServiceSourceOutcome;
typedef std::future<AddServiceSourceOutcome> AddServiceSourceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::AddServiceSourceRequest&, const AddServiceSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddServiceSourceAsyncHandler;
typedef Outcome<Error, Model::AddTestResult> AddTestOutcome;
typedef std::future<AddTestOutcome> AddTestOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::AddTestRequest&, const AddTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTestAsyncHandler;
typedef Outcome<Error, Model::ApplyGatewayRouteResult> ApplyGatewayRouteOutcome;
typedef std::future<ApplyGatewayRouteOutcome> ApplyGatewayRouteOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ApplyGatewayRouteRequest&, const ApplyGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyGatewayRouteAsyncHandler;
@@ -338,9 +373,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CloneNacosConfigResult> CloneNacosConfigOutcome;
typedef std::future<CloneNacosConfigOutcome> CloneNacosConfigOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::CloneNacosConfigRequest&, const CloneNacosConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloneNacosConfigAsyncHandler;
typedef Outcome<Error, Model::CreateAlarmRuleResult> CreateAlarmRuleOutcome;
typedef std::future<CreateAlarmRuleOutcome> CreateAlarmRuleOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::CreateAlarmRuleRequest&, const CreateAlarmRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlarmRuleAsyncHandler;
typedef Outcome<Error, Model::CreateApplicationResult> CreateApplicationOutcome;
typedef std::future<CreateApplicationOutcome> CreateApplicationOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::CreateApplicationRequest&, const CreateApplicationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateApplicationAsyncHandler;
@@ -365,12 +397,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateOrUpdateSwimmingLaneGroupResult> CreateOrUpdateSwimmingLaneGroupOutcome;
typedef std::future<CreateOrUpdateSwimmingLaneGroupOutcome> CreateOrUpdateSwimmingLaneGroupOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::CreateOrUpdateSwimmingLaneGroupRequest&, const CreateOrUpdateSwimmingLaneGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOrUpdateSwimmingLaneGroupAsyncHandler;
typedef Outcome<Error, Model::CreateVGroupResult> CreateVGroupOutcome;
typedef std::future<CreateVGroupOutcome> CreateVGroupOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::CreateVGroupRequest&, const CreateVGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVGroupAsyncHandler;
typedef Outcome<Error, Model::CreateZnodeResult> CreateZnodeOutcome;
typedef std::future<CreateZnodeOutcome> CreateZnodeOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::CreateZnodeRequest&, const CreateZnodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateZnodeAsyncHandler;
typedef Outcome<Error, Model::DeleteAlarmRuleResult> DeleteAlarmRuleOutcome;
typedef std::future<DeleteAlarmRuleOutcome> DeleteAlarmRuleOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteAlarmRuleRequest&, const DeleteAlarmRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlarmRuleAsyncHandler;
typedef Outcome<Error, Model::DeleteAuthResourceResult> DeleteAuthResourceOutcome;
typedef std::future<DeleteAuthResourceOutcome> DeleteAuthResourceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteAuthResourceRequest&, const DeleteAuthResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAuthResourceAsyncHandler;
@@ -389,6 +421,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteGatewayRouteResult> DeleteGatewayRouteOutcome;
typedef std::future<DeleteGatewayRouteOutcome> DeleteGatewayRouteOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteGatewayRouteRequest&, const DeleteGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayRouteAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayServiceResult> DeleteGatewayServiceOutcome;
typedef std::future<DeleteGatewayServiceOutcome> DeleteGatewayServiceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteGatewayServiceRequest&, const DeleteGatewayServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayServiceAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayServiceVersionResult> DeleteGatewayServiceVersionOutcome;
typedef std::future<DeleteGatewayServiceVersionOutcome> DeleteGatewayServiceVersionOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteGatewayServiceVersionRequest&, const DeleteGatewayServiceVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayServiceVersionAsyncHandler;
@@ -407,6 +442,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteNacosServiceResult> DeleteNacosServiceOutcome;
typedef std::future<DeleteNacosServiceOutcome> DeleteNacosServiceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteNacosServiceRequest&, const DeleteNacosServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNacosServiceAsyncHandler;
typedef Outcome<Error, Model::DeleteSeataServerResult> DeleteSeataServerOutcome;
typedef std::future<DeleteSeataServerOutcome> DeleteSeataServerOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteSeataServerRequest&, const DeleteSeataServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSeataServerAsyncHandler;
typedef Outcome<Error, Model::DeleteSecurityGroupRuleResult> DeleteSecurityGroupRuleOutcome;
typedef std::future<DeleteSecurityGroupRuleOutcome> DeleteSecurityGroupRuleOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteSecurityGroupRuleRequest&, const DeleteSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecurityGroupRuleAsyncHandler;
typedef Outcome<Error, Model::DeleteServiceSourceResult> DeleteServiceSourceOutcome;
typedef std::future<DeleteServiceSourceOutcome> DeleteServiceSourceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteServiceSourceRequest&, const DeleteServiceSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServiceSourceAsyncHandler;
@@ -416,15 +457,27 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteSwimmingLaneGroupResult> DeleteSwimmingLaneGroupOutcome;
typedef std::future<DeleteSwimmingLaneGroupOutcome> DeleteSwimmingLaneGroupOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteSwimmingLaneGroupRequest&, const DeleteSwimmingLaneGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSwimmingLaneGroupAsyncHandler;
typedef Outcome<Error, Model::DeleteVGroupResult> DeleteVGroupOutcome;
typedef std::future<DeleteVGroupOutcome> DeleteVGroupOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteVGroupRequest&, const DeleteVGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVGroupAsyncHandler;
typedef Outcome<Error, Model::DeleteZnodeResult> DeleteZnodeOutcome;
typedef std::future<DeleteZnodeOutcome> DeleteZnodeOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::DeleteZnodeRequest&, const DeleteZnodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteZnodeAsyncHandler;
typedef Outcome<Error, Model::ExportNacosConfigResult> ExportNacosConfigOutcome;
typedef std::future<ExportNacosConfigOutcome> ExportNacosConfigOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ExportNacosConfigRequest&, const ExportNacosConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportNacosConfigAsyncHandler;
typedef Outcome<Error, Model::GetAppMessageQueueRouteResult> GetAppMessageQueueRouteOutcome;
typedef std::future<GetAppMessageQueueRouteOutcome> GetAppMessageQueueRouteOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::GetAppMessageQueueRouteRequest&, const GetAppMessageQueueRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAppMessageQueueRouteAsyncHandler;
typedef Outcome<Error, Model::GetApplicationListResult> GetApplicationListOutcome;
typedef std::future<GetApplicationListOutcome> GetApplicationListOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::GetApplicationListRequest&, const GetApplicationListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetApplicationListAsyncHandler;
typedef Outcome<Error, Model::GetBlackWhiteListResult> GetBlackWhiteListOutcome;
typedef std::future<GetBlackWhiteListOutcome> GetBlackWhiteListOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::GetBlackWhiteListRequest&, const GetBlackWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBlackWhiteListAsyncHandler;
typedef Outcome<Error, Model::GetDashBoardUrlResult> GetDashBoardUrlOutcome;
typedef std::future<GetDashBoardUrlOutcome> GetDashBoardUrlOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::GetDashBoardUrlRequest&, const GetDashBoardUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDashBoardUrlAsyncHandler;
typedef Outcome<Error, Model::GetEngineNamepaceResult> GetEngineNamepaceOutcome;
typedef std::future<GetEngineNamepaceOutcome> GetEngineNamepaceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::GetEngineNamepaceRequest&, const GetEngineNamepaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEngineNamepaceAsyncHandler;
@@ -485,18 +538,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ImportServicesResult> ImportServicesOutcome;
typedef std::future<ImportServicesOutcome> ImportServicesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ImportServicesRequest&, const ImportServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportServicesAsyncHandler;
typedef Outcome<Error, Model::ListAlarmContactGroupsResult> ListAlarmContactGroupsOutcome;
typedef std::future<ListAlarmContactGroupsOutcome> ListAlarmContactGroupsOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListAlarmContactGroupsRequest&, const ListAlarmContactGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmContactGroupsAsyncHandler;
typedef Outcome<Error, Model::ListAlarmHistoriesResult> ListAlarmHistoriesOutcome;
typedef std::future<ListAlarmHistoriesOutcome> ListAlarmHistoriesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListAlarmHistoriesRequest&, const ListAlarmHistoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmHistoriesAsyncHandler;
typedef Outcome<Error, Model::ListAlarmItemsResult> ListAlarmItemsOutcome;
typedef std::future<ListAlarmItemsOutcome> ListAlarmItemsOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListAlarmItemsRequest&, const ListAlarmItemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmItemsAsyncHandler;
typedef Outcome<Error, Model::ListAlarmRulesResult> ListAlarmRulesOutcome;
typedef std::future<ListAlarmRulesOutcome> ListAlarmRulesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListAlarmRulesRequest&, const ListAlarmRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmRulesAsyncHandler;
typedef Outcome<Error, Model::ListAnsInstancesResult> ListAnsInstancesOutcome;
typedef std::future<ListAnsInstancesOutcome> ListAnsInstancesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListAnsInstancesRequest&, const ListAnsInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAnsInstancesAsyncHandler;
@@ -515,6 +556,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListClusterConnectionTypesResult> ListClusterConnectionTypesOutcome;
typedef std::future<ListClusterConnectionTypesOutcome> ListClusterConnectionTypesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListClusterConnectionTypesRequest&, const ListClusterConnectionTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterConnectionTypesAsyncHandler;
typedef Outcome<Error, Model::ListClusterDetailFeatureResult> ListClusterDetailFeatureOutcome;
typedef std::future<ListClusterDetailFeatureOutcome> ListClusterDetailFeatureOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListClusterDetailFeatureRequest&, const ListClusterDetailFeatureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterDetailFeatureAsyncHandler;
typedef Outcome<Error, Model::ListClusterTypesResult> ListClusterTypesOutcome;
typedef std::future<ListClusterTypesOutcome> ListClusterTypesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListClusterTypesRequest&, const ListClusterTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterTypesAsyncHandler;
@@ -548,6 +592,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListGatewaySlbResult> ListGatewaySlbOutcome;
typedef std::future<ListGatewaySlbOutcome> ListGatewaySlbOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListGatewaySlbRequest&, const ListGatewaySlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewaySlbAsyncHandler;
typedef Outcome<Error, Model::ListInstancesResult> ListInstancesOutcome;
typedef std::future<ListInstancesOutcome> ListInstancesOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListInstancesRequest&, const ListInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesAsyncHandler;
typedef Outcome<Error, Model::ListListenersByConfigResult> ListListenersByConfigOutcome;
typedef std::future<ListListenersByConfigOutcome> ListListenersByConfigOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListListenersByConfigRequest&, const ListListenersByConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListListenersByConfigAsyncHandler;
@@ -563,6 +610,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListSSLCertResult> ListSSLCertOutcome;
typedef std::future<ListSSLCertOutcome> ListSSLCertOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListSSLCertRequest&, const ListSSLCertOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSSLCertAsyncHandler;
typedef Outcome<Error, Model::ListSecurityGroupResult> ListSecurityGroupOutcome;
typedef std::future<ListSecurityGroupOutcome> ListSecurityGroupOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListSecurityGroupRequest&, const ListSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityGroupAsyncHandler;
typedef Outcome<Error, Model::ListSecurityGroupRuleResult> ListSecurityGroupRuleOutcome;
typedef std::future<ListSecurityGroupRuleOutcome> ListSecurityGroupRuleOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListSecurityGroupRuleRequest&, const ListSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityGroupRuleAsyncHandler;
typedef Outcome<Error, Model::ListServiceSourceResult> ListServiceSourceOutcome;
typedef std::future<ListServiceSourceOutcome> ListServiceSourceOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ListServiceSourceRequest&, const ListServiceSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceSourceAsyncHandler;
@@ -617,18 +670,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::QuerySwimmingLaneByIdResult> QuerySwimmingLaneByIdOutcome;
typedef std::future<QuerySwimmingLaneByIdOutcome> QuerySwimmingLaneByIdOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::QuerySwimmingLaneByIdRequest&, const QuerySwimmingLaneByIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySwimmingLaneByIdAsyncHandler;
typedef Outcome<Error, Model::QueryUserVpcResult> QueryUserVpcOutcome;
typedef std::future<QueryUserVpcOutcome> QueryUserVpcOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::QueryUserVpcRequest&, const QueryUserVpcOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryUserVpcAsyncHandler;
typedef Outcome<Error, Model::QueryZnodeDetailResult> QueryZnodeDetailOutcome;
typedef std::future<QueryZnodeDetailOutcome> QueryZnodeDetailOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::QueryZnodeDetailRequest&, const QueryZnodeDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryZnodeDetailAsyncHandler;
typedef Outcome<Error, Model::RestartClusterResult> RestartClusterOutcome;
typedef std::future<RestartClusterOutcome> RestartClusterOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::RestartClusterRequest&, const RestartClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartClusterAsyncHandler;
typedef Outcome<Error, Model::RestartSeataServerResult> RestartSeataServerOutcome;
typedef std::future<RestartSeataServerOutcome> RestartSeataServerOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::RestartSeataServerRequest&, const RestartSeataServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartSeataServerAsyncHandler;
typedef Outcome<Error, Model::RetryClusterResult> RetryClusterOutcome;
typedef std::future<RetryClusterOutcome> RetryClusterOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::RetryClusterRequest&, const RetryClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryClusterAsyncHandler;
typedef Outcome<Error, Model::ScalingClusterResult> ScalingClusterOutcome;
typedef std::future<ScalingClusterOutcome> ScalingClusterOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::ScalingClusterRequest&, const ScalingClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScalingClusterAsyncHandler;
typedef Outcome<Error, Model::SelectGatewaySlbResult> SelectGatewaySlbOutcome;
typedef std::future<SelectGatewaySlbOutcome> SelectGatewaySlbOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::SelectGatewaySlbRequest&, const SelectGatewaySlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SelectGatewaySlbAsyncHandler;
@@ -674,12 +730,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateGatewayRouteTimeoutResult> UpdateGatewayRouteTimeoutOutcome;
typedef std::future<UpdateGatewayRouteTimeoutOutcome> UpdateGatewayRouteTimeoutOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteTimeoutRequest&, const UpdateGatewayRouteTimeoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteTimeoutAsyncHandler;
typedef Outcome<Error, Model::UpdateGatewayRouteWafStatusResult> UpdateGatewayRouteWafStatusOutcome;
typedef std::future<UpdateGatewayRouteWafStatusOutcome> UpdateGatewayRouteWafStatusOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteWafStatusRequest&, const UpdateGatewayRouteWafStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteWafStatusAsyncHandler;
typedef Outcome<Error, Model::UpdateGatewayServiceTrafficPolicyResult> UpdateGatewayServiceTrafficPolicyOutcome;
typedef std::future<UpdateGatewayServiceTrafficPolicyOutcome> UpdateGatewayServiceTrafficPolicyOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateGatewayServiceTrafficPolicyRequest&, const UpdateGatewayServiceTrafficPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayServiceTrafficPolicyAsyncHandler;
typedef Outcome<Error, Model::UpdateGatewayServiceVersionResult> UpdateGatewayServiceVersionOutcome;
typedef std::future<UpdateGatewayServiceVersionOutcome> UpdateGatewayServiceVersionOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateGatewayServiceVersionRequest&, const UpdateGatewayServiceVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayServiceVersionAsyncHandler;
typedef Outcome<Error, Model::UpdateImageResult> UpdateImageOutcome;
typedef std::future<UpdateImageOutcome> UpdateImageOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateImageRequest&, const UpdateImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateImageAsyncHandler;
typedef Outcome<Error, Model::UpdateMessageQueueRouteResult> UpdateMessageQueueRouteOutcome;
typedef std::future<UpdateMessageQueueRouteOutcome> UpdateMessageQueueRouteOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateMessageQueueRouteRequest&, const UpdateMessageQueueRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMessageQueueRouteAsyncHandler;
typedef Outcome<Error, Model::UpdateNacosClusterResult> UpdateNacosClusterOutcome;
typedef std::future<UpdateNacosClusterOutcome> UpdateNacosClusterOutcomeCallable;
typedef std::function<void(const MseClient*, const Model::UpdateNacosClusterRequest&, const UpdateNacosClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNacosClusterAsyncHandler;
@@ -733,9 +798,18 @@ namespace AlibabaCloud
AddSSLCertOutcome addSSLCert(const Model::AddSSLCertRequest &request)const;
void addSSLCertAsync(const Model::AddSSLCertRequest& request, const AddSSLCertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddSSLCertOutcomeCallable addSSLCertCallable(const Model::AddSSLCertRequest& request) const;
AddSeataServerOutcome addSeataServer(const Model::AddSeataServerRequest &request)const;
void addSeataServerAsync(const Model::AddSeataServerRequest& request, const AddSeataServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddSeataServerOutcomeCallable addSeataServerCallable(const Model::AddSeataServerRequest& request) const;
AddSecurityGroupRuleOutcome addSecurityGroupRule(const Model::AddSecurityGroupRuleRequest &request)const;
void addSecurityGroupRuleAsync(const Model::AddSecurityGroupRuleRequest& request, const AddSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddSecurityGroupRuleOutcomeCallable addSecurityGroupRuleCallable(const Model::AddSecurityGroupRuleRequest& request) const;
AddServiceSourceOutcome addServiceSource(const Model::AddServiceSourceRequest &request)const;
void addServiceSourceAsync(const Model::AddServiceSourceRequest& request, const AddServiceSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddServiceSourceOutcomeCallable addServiceSourceCallable(const Model::AddServiceSourceRequest& request) const;
AddTestOutcome addTest(const Model::AddTestRequest &request)const;
void addTestAsync(const Model::AddTestRequest& request, const AddTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddTestOutcomeCallable addTestCallable(const Model::AddTestRequest& request) const;
ApplyGatewayRouteOutcome applyGatewayRoute(const Model::ApplyGatewayRouteRequest &request)const;
void applyGatewayRouteAsync(const Model::ApplyGatewayRouteRequest& request, const ApplyGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ApplyGatewayRouteOutcomeCallable applyGatewayRouteCallable(const Model::ApplyGatewayRouteRequest& request) const;
@@ -745,9 +819,6 @@ namespace AlibabaCloud
CloneNacosConfigOutcome cloneNacosConfig(const Model::CloneNacosConfigRequest &request)const;
void cloneNacosConfigAsync(const Model::CloneNacosConfigRequest& request, const CloneNacosConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CloneNacosConfigOutcomeCallable cloneNacosConfigCallable(const Model::CloneNacosConfigRequest& request) const;
CreateAlarmRuleOutcome createAlarmRule(const Model::CreateAlarmRuleRequest &request)const;
void createAlarmRuleAsync(const Model::CreateAlarmRuleRequest& request, const CreateAlarmRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAlarmRuleOutcomeCallable createAlarmRuleCallable(const Model::CreateAlarmRuleRequest& request) const;
CreateApplicationOutcome createApplication(const Model::CreateApplicationRequest &request)const;
void createApplicationAsync(const Model::CreateApplicationRequest& request, const CreateApplicationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateApplicationOutcomeCallable createApplicationCallable(const Model::CreateApplicationRequest& request) const;
@@ -772,12 +843,12 @@ namespace AlibabaCloud
CreateOrUpdateSwimmingLaneGroupOutcome createOrUpdateSwimmingLaneGroup(const Model::CreateOrUpdateSwimmingLaneGroupRequest &request)const;
void createOrUpdateSwimmingLaneGroupAsync(const Model::CreateOrUpdateSwimmingLaneGroupRequest& request, const CreateOrUpdateSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateOrUpdateSwimmingLaneGroupOutcomeCallable createOrUpdateSwimmingLaneGroupCallable(const Model::CreateOrUpdateSwimmingLaneGroupRequest& request) const;
CreateVGroupOutcome createVGroup(const Model::CreateVGroupRequest &request)const;
void createVGroupAsync(const Model::CreateVGroupRequest& request, const CreateVGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVGroupOutcomeCallable createVGroupCallable(const Model::CreateVGroupRequest& request) const;
CreateZnodeOutcome createZnode(const Model::CreateZnodeRequest &request)const;
void createZnodeAsync(const Model::CreateZnodeRequest& request, const CreateZnodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateZnodeOutcomeCallable createZnodeCallable(const Model::CreateZnodeRequest& request) const;
DeleteAlarmRuleOutcome deleteAlarmRule(const Model::DeleteAlarmRuleRequest &request)const;
void deleteAlarmRuleAsync(const Model::DeleteAlarmRuleRequest& request, const DeleteAlarmRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAlarmRuleOutcomeCallable deleteAlarmRuleCallable(const Model::DeleteAlarmRuleRequest& request) const;
DeleteAuthResourceOutcome deleteAuthResource(const Model::DeleteAuthResourceRequest &request)const;
void deleteAuthResourceAsync(const Model::DeleteAuthResourceRequest& request, const DeleteAuthResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAuthResourceOutcomeCallable deleteAuthResourceCallable(const Model::DeleteAuthResourceRequest& request) const;
@@ -796,6 +867,9 @@ namespace AlibabaCloud
DeleteGatewayRouteOutcome deleteGatewayRoute(const Model::DeleteGatewayRouteRequest &request)const;
void deleteGatewayRouteAsync(const Model::DeleteGatewayRouteRequest& request, const DeleteGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayRouteOutcomeCallable deleteGatewayRouteCallable(const Model::DeleteGatewayRouteRequest& request) const;
DeleteGatewayServiceOutcome deleteGatewayService(const Model::DeleteGatewayServiceRequest &request)const;
void deleteGatewayServiceAsync(const Model::DeleteGatewayServiceRequest& request, const DeleteGatewayServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayServiceOutcomeCallable deleteGatewayServiceCallable(const Model::DeleteGatewayServiceRequest& request) const;
DeleteGatewayServiceVersionOutcome deleteGatewayServiceVersion(const Model::DeleteGatewayServiceVersionRequest &request)const;
void deleteGatewayServiceVersionAsync(const Model::DeleteGatewayServiceVersionRequest& request, const DeleteGatewayServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayServiceVersionOutcomeCallable deleteGatewayServiceVersionCallable(const Model::DeleteGatewayServiceVersionRequest& request) const;
@@ -814,6 +888,12 @@ namespace AlibabaCloud
DeleteNacosServiceOutcome deleteNacosService(const Model::DeleteNacosServiceRequest &request)const;
void deleteNacosServiceAsync(const Model::DeleteNacosServiceRequest& request, const DeleteNacosServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteNacosServiceOutcomeCallable deleteNacosServiceCallable(const Model::DeleteNacosServiceRequest& request) const;
DeleteSeataServerOutcome deleteSeataServer(const Model::DeleteSeataServerRequest &request)const;
void deleteSeataServerAsync(const Model::DeleteSeataServerRequest& request, const DeleteSeataServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSeataServerOutcomeCallable deleteSeataServerCallable(const Model::DeleteSeataServerRequest& request) const;
DeleteSecurityGroupRuleOutcome deleteSecurityGroupRule(const Model::DeleteSecurityGroupRuleRequest &request)const;
void deleteSecurityGroupRuleAsync(const Model::DeleteSecurityGroupRuleRequest& request, const DeleteSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSecurityGroupRuleOutcomeCallable deleteSecurityGroupRuleCallable(const Model::DeleteSecurityGroupRuleRequest& request) const;
DeleteServiceSourceOutcome deleteServiceSource(const Model::DeleteServiceSourceRequest &request)const;
void deleteServiceSourceAsync(const Model::DeleteServiceSourceRequest& request, const DeleteServiceSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteServiceSourceOutcomeCallable deleteServiceSourceCallable(const Model::DeleteServiceSourceRequest& request) const;
@@ -823,15 +903,27 @@ namespace AlibabaCloud
DeleteSwimmingLaneGroupOutcome deleteSwimmingLaneGroup(const Model::DeleteSwimmingLaneGroupRequest &request)const;
void deleteSwimmingLaneGroupAsync(const Model::DeleteSwimmingLaneGroupRequest& request, const DeleteSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSwimmingLaneGroupOutcomeCallable deleteSwimmingLaneGroupCallable(const Model::DeleteSwimmingLaneGroupRequest& request) const;
DeleteVGroupOutcome deleteVGroup(const Model::DeleteVGroupRequest &request)const;
void deleteVGroupAsync(const Model::DeleteVGroupRequest& request, const DeleteVGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVGroupOutcomeCallable deleteVGroupCallable(const Model::DeleteVGroupRequest& request) const;
DeleteZnodeOutcome deleteZnode(const Model::DeleteZnodeRequest &request)const;
void deleteZnodeAsync(const Model::DeleteZnodeRequest& request, const DeleteZnodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteZnodeOutcomeCallable deleteZnodeCallable(const Model::DeleteZnodeRequest& request) const;
ExportNacosConfigOutcome exportNacosConfig(const Model::ExportNacosConfigRequest &request)const;
void exportNacosConfigAsync(const Model::ExportNacosConfigRequest& request, const ExportNacosConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExportNacosConfigOutcomeCallable exportNacosConfigCallable(const Model::ExportNacosConfigRequest& request) const;
GetAppMessageQueueRouteOutcome getAppMessageQueueRoute(const Model::GetAppMessageQueueRouteRequest &request)const;
void getAppMessageQueueRouteAsync(const Model::GetAppMessageQueueRouteRequest& request, const GetAppMessageQueueRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAppMessageQueueRouteOutcomeCallable getAppMessageQueueRouteCallable(const Model::GetAppMessageQueueRouteRequest& request) const;
GetApplicationListOutcome getApplicationList(const Model::GetApplicationListRequest &request)const;
void getApplicationListAsync(const Model::GetApplicationListRequest& request, const GetApplicationListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetApplicationListOutcomeCallable getApplicationListCallable(const Model::GetApplicationListRequest& request) const;
GetBlackWhiteListOutcome getBlackWhiteList(const Model::GetBlackWhiteListRequest &request)const;
void getBlackWhiteListAsync(const Model::GetBlackWhiteListRequest& request, const GetBlackWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetBlackWhiteListOutcomeCallable getBlackWhiteListCallable(const Model::GetBlackWhiteListRequest& request) const;
GetDashBoardUrlOutcome getDashBoardUrl(const Model::GetDashBoardUrlRequest &request)const;
void getDashBoardUrlAsync(const Model::GetDashBoardUrlRequest& request, const GetDashBoardUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDashBoardUrlOutcomeCallable getDashBoardUrlCallable(const Model::GetDashBoardUrlRequest& request) const;
GetEngineNamepaceOutcome getEngineNamepace(const Model::GetEngineNamepaceRequest &request)const;
void getEngineNamepaceAsync(const Model::GetEngineNamepaceRequest& request, const GetEngineNamepaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetEngineNamepaceOutcomeCallable getEngineNamepaceCallable(const Model::GetEngineNamepaceRequest& request) const;
@@ -892,18 +984,6 @@ namespace AlibabaCloud
ImportServicesOutcome importServices(const Model::ImportServicesRequest &request)const;
void importServicesAsync(const Model::ImportServicesRequest& request, const ImportServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImportServicesOutcomeCallable importServicesCallable(const Model::ImportServicesRequest& request) const;
ListAlarmContactGroupsOutcome listAlarmContactGroups(const Model::ListAlarmContactGroupsRequest &request)const;
void listAlarmContactGroupsAsync(const Model::ListAlarmContactGroupsRequest& request, const ListAlarmContactGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAlarmContactGroupsOutcomeCallable listAlarmContactGroupsCallable(const Model::ListAlarmContactGroupsRequest& request) const;
ListAlarmHistoriesOutcome listAlarmHistories(const Model::ListAlarmHistoriesRequest &request)const;
void listAlarmHistoriesAsync(const Model::ListAlarmHistoriesRequest& request, const ListAlarmHistoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAlarmHistoriesOutcomeCallable listAlarmHistoriesCallable(const Model::ListAlarmHistoriesRequest& request) const;
ListAlarmItemsOutcome listAlarmItems(const Model::ListAlarmItemsRequest &request)const;
void listAlarmItemsAsync(const Model::ListAlarmItemsRequest& request, const ListAlarmItemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAlarmItemsOutcomeCallable listAlarmItemsCallable(const Model::ListAlarmItemsRequest& request) const;
ListAlarmRulesOutcome listAlarmRules(const Model::ListAlarmRulesRequest &request)const;
void listAlarmRulesAsync(const Model::ListAlarmRulesRequest& request, const ListAlarmRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAlarmRulesOutcomeCallable listAlarmRulesCallable(const Model::ListAlarmRulesRequest& request) const;
ListAnsInstancesOutcome listAnsInstances(const Model::ListAnsInstancesRequest &request)const;
void listAnsInstancesAsync(const Model::ListAnsInstancesRequest& request, const ListAnsInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAnsInstancesOutcomeCallable listAnsInstancesCallable(const Model::ListAnsInstancesRequest& request) const;
@@ -922,6 +1002,9 @@ namespace AlibabaCloud
ListClusterConnectionTypesOutcome listClusterConnectionTypes(const Model::ListClusterConnectionTypesRequest &request)const;
void listClusterConnectionTypesAsync(const Model::ListClusterConnectionTypesRequest& request, const ListClusterConnectionTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClusterConnectionTypesOutcomeCallable listClusterConnectionTypesCallable(const Model::ListClusterConnectionTypesRequest& request) const;
ListClusterDetailFeatureOutcome listClusterDetailFeature(const Model::ListClusterDetailFeatureRequest &request)const;
void listClusterDetailFeatureAsync(const Model::ListClusterDetailFeatureRequest& request, const ListClusterDetailFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClusterDetailFeatureOutcomeCallable listClusterDetailFeatureCallable(const Model::ListClusterDetailFeatureRequest& request) const;
ListClusterTypesOutcome listClusterTypes(const Model::ListClusterTypesRequest &request)const;
void listClusterTypesAsync(const Model::ListClusterTypesRequest& request, const ListClusterTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListClusterTypesOutcomeCallable listClusterTypesCallable(const Model::ListClusterTypesRequest& request) const;
@@ -955,6 +1038,9 @@ namespace AlibabaCloud
ListGatewaySlbOutcome listGatewaySlb(const Model::ListGatewaySlbRequest &request)const;
void listGatewaySlbAsync(const Model::ListGatewaySlbRequest& request, const ListGatewaySlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListGatewaySlbOutcomeCallable listGatewaySlbCallable(const Model::ListGatewaySlbRequest& request) const;
ListInstancesOutcome listInstances(const Model::ListInstancesRequest &request)const;
void listInstancesAsync(const Model::ListInstancesRequest& request, const ListInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListInstancesOutcomeCallable listInstancesCallable(const Model::ListInstancesRequest& request) const;
ListListenersByConfigOutcome listListenersByConfig(const Model::ListListenersByConfigRequest &request)const;
void listListenersByConfigAsync(const Model::ListListenersByConfigRequest& request, const ListListenersByConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListListenersByConfigOutcomeCallable listListenersByConfigCallable(const Model::ListListenersByConfigRequest& request) const;
@@ -970,6 +1056,12 @@ namespace AlibabaCloud
ListSSLCertOutcome listSSLCert(const Model::ListSSLCertRequest &request)const;
void listSSLCertAsync(const Model::ListSSLCertRequest& request, const ListSSLCertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListSSLCertOutcomeCallable listSSLCertCallable(const Model::ListSSLCertRequest& request) const;
ListSecurityGroupOutcome listSecurityGroup(const Model::ListSecurityGroupRequest &request)const;
void listSecurityGroupAsync(const Model::ListSecurityGroupRequest& request, const ListSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListSecurityGroupOutcomeCallable listSecurityGroupCallable(const Model::ListSecurityGroupRequest& request) const;
ListSecurityGroupRuleOutcome listSecurityGroupRule(const Model::ListSecurityGroupRuleRequest &request)const;
void listSecurityGroupRuleAsync(const Model::ListSecurityGroupRuleRequest& request, const ListSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListSecurityGroupRuleOutcomeCallable listSecurityGroupRuleCallable(const Model::ListSecurityGroupRuleRequest& request) const;
ListServiceSourceOutcome listServiceSource(const Model::ListServiceSourceRequest &request)const;
void listServiceSourceAsync(const Model::ListServiceSourceRequest& request, const ListServiceSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListServiceSourceOutcomeCallable listServiceSourceCallable(const Model::ListServiceSourceRequest& request) const;
@@ -1024,18 +1116,21 @@ namespace AlibabaCloud
QuerySwimmingLaneByIdOutcome querySwimmingLaneById(const Model::QuerySwimmingLaneByIdRequest &request)const;
void querySwimmingLaneByIdAsync(const Model::QuerySwimmingLaneByIdRequest& request, const QuerySwimmingLaneByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QuerySwimmingLaneByIdOutcomeCallable querySwimmingLaneByIdCallable(const Model::QuerySwimmingLaneByIdRequest& request) const;
QueryUserVpcOutcome queryUserVpc(const Model::QueryUserVpcRequest &request)const;
void queryUserVpcAsync(const Model::QueryUserVpcRequest& request, const QueryUserVpcAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryUserVpcOutcomeCallable queryUserVpcCallable(const Model::QueryUserVpcRequest& request) const;
QueryZnodeDetailOutcome queryZnodeDetail(const Model::QueryZnodeDetailRequest &request)const;
void queryZnodeDetailAsync(const Model::QueryZnodeDetailRequest& request, const QueryZnodeDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryZnodeDetailOutcomeCallable queryZnodeDetailCallable(const Model::QueryZnodeDetailRequest& request) const;
RestartClusterOutcome restartCluster(const Model::RestartClusterRequest &request)const;
void restartClusterAsync(const Model::RestartClusterRequest& request, const RestartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartClusterOutcomeCallable restartClusterCallable(const Model::RestartClusterRequest& request) const;
RestartSeataServerOutcome restartSeataServer(const Model::RestartSeataServerRequest &request)const;
void restartSeataServerAsync(const Model::RestartSeataServerRequest& request, const RestartSeataServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartSeataServerOutcomeCallable restartSeataServerCallable(const Model::RestartSeataServerRequest& request) const;
RetryClusterOutcome retryCluster(const Model::RetryClusterRequest &request)const;
void retryClusterAsync(const Model::RetryClusterRequest& request, const RetryClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RetryClusterOutcomeCallable retryClusterCallable(const Model::RetryClusterRequest& request) const;
ScalingClusterOutcome scalingCluster(const Model::ScalingClusterRequest &request)const;
void scalingClusterAsync(const Model::ScalingClusterRequest& request, const ScalingClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ScalingClusterOutcomeCallable scalingClusterCallable(const Model::ScalingClusterRequest& request) const;
SelectGatewaySlbOutcome selectGatewaySlb(const Model::SelectGatewaySlbRequest &request)const;
void selectGatewaySlbAsync(const Model::SelectGatewaySlbRequest& request, const SelectGatewaySlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SelectGatewaySlbOutcomeCallable selectGatewaySlbCallable(const Model::SelectGatewaySlbRequest& request) const;
@@ -1081,12 +1176,21 @@ namespace AlibabaCloud
UpdateGatewayRouteTimeoutOutcome updateGatewayRouteTimeout(const Model::UpdateGatewayRouteTimeoutRequest &request)const;
void updateGatewayRouteTimeoutAsync(const Model::UpdateGatewayRouteTimeoutRequest& request, const UpdateGatewayRouteTimeoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateGatewayRouteTimeoutOutcomeCallable updateGatewayRouteTimeoutCallable(const Model::UpdateGatewayRouteTimeoutRequest& request) const;
UpdateGatewayRouteWafStatusOutcome updateGatewayRouteWafStatus(const Model::UpdateGatewayRouteWafStatusRequest &request)const;
void updateGatewayRouteWafStatusAsync(const Model::UpdateGatewayRouteWafStatusRequest& request, const UpdateGatewayRouteWafStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateGatewayRouteWafStatusOutcomeCallable updateGatewayRouteWafStatusCallable(const Model::UpdateGatewayRouteWafStatusRequest& request) const;
UpdateGatewayServiceTrafficPolicyOutcome updateGatewayServiceTrafficPolicy(const Model::UpdateGatewayServiceTrafficPolicyRequest &request)const;
void updateGatewayServiceTrafficPolicyAsync(const Model::UpdateGatewayServiceTrafficPolicyRequest& request, const UpdateGatewayServiceTrafficPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateGatewayServiceTrafficPolicyOutcomeCallable updateGatewayServiceTrafficPolicyCallable(const Model::UpdateGatewayServiceTrafficPolicyRequest& request) const;
UpdateGatewayServiceVersionOutcome updateGatewayServiceVersion(const Model::UpdateGatewayServiceVersionRequest &request)const;
void updateGatewayServiceVersionAsync(const Model::UpdateGatewayServiceVersionRequest& request, const UpdateGatewayServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateGatewayServiceVersionOutcomeCallable updateGatewayServiceVersionCallable(const Model::UpdateGatewayServiceVersionRequest& request) const;
UpdateImageOutcome updateImage(const Model::UpdateImageRequest &request)const;
void updateImageAsync(const Model::UpdateImageRequest& request, const UpdateImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateImageOutcomeCallable updateImageCallable(const Model::UpdateImageRequest& request) const;
UpdateMessageQueueRouteOutcome updateMessageQueueRoute(const Model::UpdateMessageQueueRouteRequest &request)const;
void updateMessageQueueRouteAsync(const Model::UpdateMessageQueueRouteRequest& request, const UpdateMessageQueueRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateMessageQueueRouteOutcomeCallable updateMessageQueueRouteCallable(const Model::UpdateMessageQueueRouteRequest& request) const;
UpdateNacosClusterOutcome updateNacosCluster(const Model::UpdateNacosClusterRequest &request)const;
void updateNacosClusterAsync(const Model::UpdateNacosClusterRequest& request, const UpdateNacosClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateNacosClusterOutcomeCallable updateNacosClusterCallable(const Model::UpdateNacosClusterRequest& request) const;

3
mse/include/alibabacloud/mse/model/AddGatewayRouteRequest.h
View File

@@ -84,6 +84,8 @@ public:
void setGatewayId(long gatewayId);
int getRouteOrder() const;
void setRouteOrder(int routeOrder);
bool getEnableWaf() const;
void setEnableWaf(bool enableWaf);
std::vector<Services> getServices() const;
void setServices(const std::vector<Services> &services);
Predicates getPredicates() const;
@@ -104,6 +106,7 @@ private:
long domainId_;
long gatewayId_;
int routeOrder_;
bool enableWaf_;
std::vector<Services> services_;
Predicates predicates_;
RedirectJSON redirectJSON_;

51
mse/include/alibabacloud/mse/model/ScalingClusterRequest.h → mse/include/alibabacloud/mse/model/AddSeataServerRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERREQUEST_H_
#ifndef ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,35 +26,38 @@
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ScalingClusterRequest : public RpcServiceRequest {
class ALIBABACLOUD_MSE_EXPORT AddSeataServerRequest : public RpcServiceRequest {
public:
ScalingClusterRequest();
~ScalingClusterRequest();
std::string getClusterSpecification() const;
void setClusterSpecification(const std::string &clusterSpecification);
int getCpu() const;
void setCpu(int cpu);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
long getMemoryCapacity() const;
void setMemoryCapacity(long memoryCapacity);
int getInstanceCount() const;
void setInstanceCount(int instanceCount);
AddSeataServerRequest();
~AddSeataServerRequest();
int getReplica() const;
void setReplica(int replica);
std::string getPrimaryUser() const;
void setPrimaryUser(const std::string &primaryUser);
std::string getVpc() const;
void setVpc(const std::string &vpc);
std::string getVswitch() const;
void setVswitch(const std::string &vswitch);
std::string getName() const;
void setName(const std::string &name);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::string clusterSpecification_;
int cpu_;
std::string clusterId_;
std::string instanceId_;
long memoryCapacity_;
int instanceCount_;
int replica_;
std::string primaryUser_;
std::string vpc_;
std::string vswitch_;
std::string name_;
std::string acceptLanguage_;
std::string zoneId_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERREQUEST_H_
#endif // !ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERREQUEST_H_

22
mse/include/alibabacloud/mse/model/ScalingClusterResult.h → mse/include/alibabacloud/mse/model/AddSeataServerResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERRESULT_H_
#ifndef ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERRESULT_H_
#include <string>
#include <vector>
@@ -29,27 +29,31 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ScalingClusterResult : public ServiceResult
class ALIBABACLOUD_MSE_EXPORT AddSeataServerResult : public ServiceResult
{
public:
ScalingClusterResult();
explicit ScalingClusterResult(const std::string &payload);
~ScalingClusterResult();
AddSeataServerResult();
explicit AddSeataServerResult(const std::string &payload);
~AddSeataServerResult();
std::string getMessage()const;
std::string getErrorCode()const;
int getHttpStatusCode()const;
std::string getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string errorCode_;
int httpStatusCode_;
std::string data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERRESULT_H_
#endif // !ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERRESULT_H_

54
mse/include/alibabacloud/mse/model/AddSecurityGroupRuleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT AddSecurityGroupRuleRequest : public RpcServiceRequest {
public:
AddSecurityGroupRuleRequest();
~AddSecurityGroupRuleRequest();
std::string getPortRange() const;
void setPortRange(const std::string &portRange);
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string portRange_;
std::string gatewayUniqueId_;
std::string securityGroupId_;
std::string description_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULEREQUEST_H_

59
mse/include/alibabacloud/mse/model/AddSecurityGroupRuleResult.h Normal file
View File

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

8
mse/include/alibabacloud/mse/model/AddServiceSourceRequest.h
View File

@@ -28,8 +28,15 @@ namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT AddServiceSourceRequest : public RpcServiceRequest {
public:
struct IngressOptionsRequest {
bool enableIngress;
std::string watchNamespace;
std::string ingressClass;
};
AddServiceSourceRequest();
~AddServiceSourceRequest();
IngressOptionsRequest getIngressOptionsRequest() const;
void setIngressOptionsRequest(const IngressOptionsRequest &ingressOptionsRequest);
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getSource() const;
@@ -44,6 +51,7 @@ public:
void setAcceptLanguage(const std::string &acceptLanguage);
private:
IngressOptionsRequest ingressOptionsRequest_;
std::string gatewayUniqueId_;
std::string source_;
std::string type_;

27
mse/include/alibabacloud/mse/model/ListAlarmContactGroupsRequest.h → mse/include/alibabacloud/mse/model/AddTestRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSREQUEST_H_
#ifndef ALIBABACLOUD_MSE_MODEL_ADDTESTREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_ADDTESTREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,26 +26,29 @@
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListAlarmContactGroupsRequest : public RpcServiceRequest {
class ALIBABACLOUD_MSE_EXPORT AddTestRequest : public RpcServiceRequest {
public:
ListAlarmContactGroupsRequest();
~ListAlarmContactGroupsRequest();
int getPageNum() const;
void setPageNum(int pageNum);
std::string getRequestPars() const;
void setRequestPars(const std::string &requestPars);
AddTestRequest();
~AddTestRequest();
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getOrderItem() const;
void setOrderItem(const std::string &orderItem);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
bool getDescSort() const;
void setDescSort(bool descSort);
private:
int pageNum_;
std::string requestPars_;
int pageNumber_;
std::string orderItem_;
int pageSize_;
std::string acceptLanguage_;
bool descSort_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSREQUEST_H_
#endif // !ALIBABACLOUD_MSE_MODEL_ADDTESTREQUEST_H_

117
mse/include/alibabacloud/mse/model/AddTestResult.h 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.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_ADDTESTRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_ADDTESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT AddTestResult : public ServiceResult
{
public:
struct Data
{
struct Gateways
{
struct SlbItem
{
std::string slbId;
std::string slbPort;
std::string statusDesc;
std::string type;
std::string gatewaySlbMode;
std::string slbIp;
std::string gatewaySlbStatus;
std::string slbSpec;
};
struct InternetSlbItem
{
std::string slbId;
std::string slbPort;
std::string statusDesc;
std::string type;
std::string gatewaySlbMode;
std::string slbIp;
std::string gatewaySlbStatus;
std::string slbSpec;
std::string internetNetworkFlow;
};
std::string currentVersion;
std::vector<Gateways::SlbItem> slb;
std::string gmtModified;
std::string vswitch2;
std::string gatewayType;
bool upgrade;
std::string name;
std::string statusDesc;
bool armsOn;
std::vector<Gateways::InternetSlbItem> internetSlb;
int status;
bool mustUpgrade;
std::string instanceId;
bool ahasOn;
int replica;
std::string endDate;
std::string gatewayUniqueId;
std::string gmtCreate;
std::string latestVersion;
std::string chargeType;
std::string region;
std::string primaryUser;
long id;
std::string tag;
std::string spec;
};
int pageSize;
int pageNumber;
long totalSize;
std::vector<Gateways> result;
};
AddTestResult();
explicit AddTestResult(const std::string &payload);
~AddTestResult();
std::string getMessage()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_ADDTESTRESULT_H_

72
mse/include/alibabacloud/mse/model/CreateAlarmRuleRequest.h
View File

@@ -1,72 +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_MSE_MODEL_CREATEALARMRULEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_CREATEALARMRULEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT CreateAlarmRuleRequest : public RpcServiceRequest {
public:
CreateAlarmRuleRequest();
~CreateAlarmRuleRequest();
int getNValue() const;
void setNValue(int nValue);
std::string getAlarmItem() const;
void setAlarmItem(const std::string &alarmItem);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string get_Operator() const;
void set_Operator(const std::string &_operator);
std::string getAlarmAliasName() const;
void setAlarmAliasName(const std::string &alarmAliasName);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getContactGroupIds() const;
void setContactGroupIds(const std::string &contactGroupIds);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getAlertWay() const;
void setAlertWay(const std::string &alertWay);
std::string getAggregates() const;
void setAggregates(const std::string &aggregates);
float getValue() const;
void setValue(float value);
private:
int nValue_;
std::string alarmItem_;
std::string clusterId_;
std::string _operator_;
std::string alarmAliasName_;
std::string instanceId_;
std::string contactGroupIds_;
std::string acceptLanguage_;
std::string alertWay_;
std::string aggregates_;
float value_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_CREATEALARMRULEREQUEST_H_

6
mse/include/alibabacloud/mse/model/CreateApplicationRequest.h
View File

@@ -38,8 +38,12 @@ public:
void setExtraInfo(const std::string &extraInfo);
std::string getAppName() const;
void setAppName(const std::string &appName);
std::string getSwitchEnable() const;
void setSwitchEnable(const std::string &switchEnable);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getSentinelEnable() const;
void setSentinelEnable(const std::string &sentinelEnable);
std::string getRegion() const;
void setRegion(const std::string &region);
@@ -48,7 +52,9 @@ private:
std::string source_;
std::string extraInfo_;
std::string appName_;
std::string switchEnable_;
std::string acceptLanguage_;
std::string sentinelEnable_;
std::string region_;
};
} // namespace Model

3
mse/include/alibabacloud/mse/model/CreateEngineNamespaceRequest.h
View File

@@ -40,6 +40,8 @@ public:
void setName(const std::string &name);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getId() const;
void setId(const std::string &id);
std::string getDesc() const;
void setDesc(const std::string &desc);
@@ -49,6 +51,7 @@ private:
int serviceCount_;
std::string name_;
std::string acceptLanguage_;
std::string id_;
std::string desc_;
};
} // namespace Model

54
mse/include/alibabacloud/mse/model/CreateVGroupRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_CREATEVGROUPREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_CREATEVGROUPREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT CreateVGroupRequest : public RpcServiceRequest {
public:
CreateVGroupRequest();
~CreateVGroupRequest();
std::string getPrimaryUser() const;
void setPrimaryUser(const std::string &primaryUser);
std::string getName() const;
void setName(const std::string &name);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getSeataServerUniqueId() const;
void setSeataServerUniqueId(const std::string &seataServerUniqueId);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::string primaryUser_;
std::string name_;
std::string acceptLanguage_;
std::string seataServerUniqueId_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_CREATEVGROUPREQUEST_H_

22
mse/include/alibabacloud/mse/model/CreateAlarmRuleResult.h → mse/include/alibabacloud/mse/model/CreateVGroupResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_CREATEALARMRULERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_CREATEALARMRULERESULT_H_
#ifndef ALIBABACLOUD_MSE_MODEL_CREATEVGROUPRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_CREATEVGROUPRESULT_H_
#include <string>
#include <vector>
@@ -29,27 +29,31 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT CreateAlarmRuleResult : public ServiceResult
class ALIBABACLOUD_MSE_EXPORT CreateVGroupResult : public ServiceResult
{
public:
CreateAlarmRuleResult();
explicit CreateAlarmRuleResult(const std::string &payload);
~CreateAlarmRuleResult();
CreateVGroupResult();
explicit CreateVGroupResult(const std::string &payload);
~CreateVGroupResult();
std::string getMessage()const;
std::string getErrorCode()const;
int getHttpStatusCode()const;
std::string getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string errorCode_;
int httpStatusCode_;
std::string data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_CREATEALARMRULERESULT_H_
#endif // !ALIBABACLOUD_MSE_MODEL_CREATEVGROUPRESULT_H_

2
mse/include/alibabacloud/mse/model/DeleteGatewayDomainResult.h
View File

@@ -38,7 +38,7 @@ namespace AlibabaCloud
std::string gmtCreate;
bool mustHttps;
std::string gmtModified;
int certIdentifier;
std::string certIdentifier;
long id;
long gatewayId;
std::string protocol;

51
mse/include/alibabacloud/mse/model/DeleteGatewayServiceRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT DeleteGatewayServiceRequest : public RpcServiceRequest {
public:
DeleteGatewayServiceRequest();
~DeleteGatewayServiceRequest();
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getServiceId() const;
void setServiceId(const std::string &serviceId);
long getGatewayId() const;
void setGatewayId(long gatewayId);
private:
std::string gatewayUniqueId_;
std::string acceptLanguage_;
std::string serviceId_;
long gatewayId_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICEREQUEST_H_

49
mse/include/alibabacloud/mse/model/ListAlarmContactGroupsResult.h → mse/include/alibabacloud/mse/model/DeleteGatewayServiceResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSRESULT_H_
#ifndef ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICERESULT_H_
#include <string>
#include <vector>
@@ -29,42 +29,47 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListAlarmContactGroupsResult : public ServiceResult
class ALIBABACLOUD_MSE_EXPORT DeleteGatewayServiceResult : public ServiceResult
{
public:
struct AlarmContactGroupModel
struct Data
{
std::string contactGroupId;
std::string contactGroupName;
std::string groupName;
std::string sourceType;
long sourceId;
std::string metaInfo;
std::string gmtModified;
std::string _namespace;
long gatewayId;
std::vector<std::string> ips;
std::string name;
std::string gatewayUniqueId;
std::string gmtCreate;
std::string serviceNameInRegistry;
long id;
};
ListAlarmContactGroupsResult();
explicit ListAlarmContactGroupsResult(const std::string &payload);
~ListAlarmContactGroupsResult();
std::string getHttpCode()const;
int getTotalCount()const;
DeleteGatewayServiceResult();
explicit DeleteGatewayServiceResult(const std::string &payload);
~DeleteGatewayServiceResult();
std::string getMessage()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<AlarmContactGroupModel> getData()const;
std::string getErrorCode()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string httpCode_;
int totalCount_;
std::string message_;
int pageSize_;
int pageNumber_;
std::vector<AlarmContactGroupModel> data_;
std::string errorCode_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSRESULT_H_
#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICERESULT_H_

45
mse/include/alibabacloud/mse/model/DeleteSeataServerRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT DeleteSeataServerRequest : public RpcServiceRequest {
public:
DeleteSeataServerRequest();
~DeleteSeataServerRequest();
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getSeataServerUniqueId() const;
void setSeataServerUniqueId(const std::string &seataServerUniqueId);
private:
std::string acceptLanguage_;
std::string seataServerUniqueId_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERREQUEST_H_

59
mse/include/alibabacloud/mse/model/DeleteSeataServerResult.h Normal file
View File

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

48
mse/include/alibabacloud/mse/model/DeleteSecurityGroupRuleRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT DeleteSecurityGroupRuleRequest : public RpcServiceRequest {
public:
DeleteSecurityGroupRuleRequest();
~DeleteSecurityGroupRuleRequest();
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
long getId() const;
void setId(long id);
private:
std::string gatewayUniqueId_;
std::string acceptLanguage_;
long id_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULEREQUEST_H_

71
mse/include/alibabacloud/mse/model/DeleteSecurityGroupRuleResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT DeleteSecurityGroupRuleResult : public ServiceResult
{
public:
struct Data
{
std::string gatewayUniqueId;
std::string portRange;
std::string gmtCreate;
std::string description;
std::string securityGroupId;
std::string gmtModified;
std::string ipProtocol;
long id;
long gatewayId;
};
DeleteSecurityGroupRuleResult();
explicit DeleteSecurityGroupRuleResult(const std::string &payload);
~DeleteSecurityGroupRuleResult();
std::string getMessage()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULERESULT_H_

18
mse/include/alibabacloud/mse/model/ListAlarmItemsRequest.h → mse/include/alibabacloud/mse/model/DeleteVGroupRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSREQUEST_H_
#ifndef ALIBABACLOUD_MSE_MODEL_DELETEVGROUPREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_DELETEVGROUPREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,20 +26,20 @@
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListAlarmItemsRequest : public RpcServiceRequest {
class ALIBABACLOUD_MSE_EXPORT DeleteVGroupRequest : public RpcServiceRequest {
public:
ListAlarmItemsRequest();
~ListAlarmItemsRequest();
std::string getRequestPars() const;
void setRequestPars(const std::string &requestPars);
DeleteVGroupRequest();
~DeleteVGroupRequest();
std::string getName() const;
void setName(const std::string &name);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string requestPars_;
std::string name_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSREQUEST_H_
#endif // !ALIBABACLOUD_MSE_MODEL_DELETEVGROUPREQUEST_H_

59
mse/include/alibabacloud/mse/model/DeleteVGroupResult.h Normal file
View File

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

48
mse/include/alibabacloud/mse/model/GetAppMessageQueueRouteRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT GetAppMessageQueueRouteRequest : public RpcServiceRequest {
public:
GetAppMessageQueueRouteRequest();
~GetAppMessageQueueRouteRequest();
std::string getAppId() const;
void setAppId(const std::string &appId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::string appId_;
std::string acceptLanguage_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTEREQUEST_H_

66
mse/include/alibabacloud/mse/model/GetAppMessageQueueRouteResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT GetAppMessageQueueRouteResult : public ServiceResult
{
public:
struct Data
{
std::string appId;
std::string region;
bool enable;
std::vector<std::string> tags;
};
GetAppMessageQueueRouteResult();
explicit GetAppMessageQueueRouteResult(const std::string &payload);
~GetAppMessageQueueRouteResult();
std::string getMessage()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTERESULT_H_

54
mse/include/alibabacloud/mse/model/ListAlarmHistoriesRequest.h → mse/include/alibabacloud/mse/model/GetApplicationListRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESREQUEST_H_
#ifndef ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,38 +26,44 @@
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListAlarmHistoriesRequest : public RpcServiceRequest {
class ALIBABACLOUD_MSE_EXPORT GetApplicationListRequest : public RpcServiceRequest {
public:
ListAlarmHistoriesRequest();
~ListAlarmHistoriesRequest();
long getEndTime() const;
void setEndTime(long endTime);
std::string getAlarmMseType() const;
void setAlarmMseType(const std::string &alarmMseType);
long getStartTime() const;
void setStartTime(long startTime);
int getPageNum() const;
void setPageNum(int pageNum);
std::string getRequestPars() const;
void setRequestPars(const std::string &requestPars);
GetApplicationListRequest();
~GetApplicationListRequest();
std::string getLanguage() const;
void setLanguage(const std::string &language);
std::string getSource() const;
void setSource(const std::string &source);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAppName() const;
void setAppName(const std::string &appName);
int getPageSize() const;
void setPageSize(int pageSize);
bool getSwitchEnable() const;
void setSwitchEnable(bool switchEnable);
std::string getAppId() const;
void setAppId(const std::string &appId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getAlarmName() const;
void setAlarmName(const std::string &alarmName);
bool getSentinelEnable() const;
void setSentinelEnable(bool sentinelEnable);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
long endTime_;
std::string alarmMseType_;
long startTime_;
int pageNum_;
std::string requestPars_;
std::string language_;
std::string source_;
int pageNumber_;
std::string appName_;
int pageSize_;
bool switchEnable_;
std::string appId_;
std::string acceptLanguage_;
std::string alarmName_;
bool sentinelEnable_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESREQUEST_H_
#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTREQUEST_H_

57
mse/include/alibabacloud/mse/model/ListAlarmHistoriesResult.h → mse/include/alibabacloud/mse/model/GetApplicationListResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESRESULT_H_
#ifndef ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTRESULT_H_
#include <string>
#include <vector>
@@ -29,46 +29,51 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListAlarmHistoriesResult : public ServiceResult
class ALIBABACLOUD_MSE_EXPORT GetApplicationListResult : public ServiceResult
{
public:
struct AlarmHistoryModel
struct Data
{
std::string alarmName;
std::string alarmTime;
std::string alarmEmail;
std::string alarmDingDing;
std::string alarmPhone;
std::string alarmContent;
struct ApplicationList
{
long status;
int instancesNumber;
std::string appId;
std::string language;
std::string userId;
std::string extraInfo;
std::string regionId;
std::string source;
std::string appName;
std::string licenseKey;
};
int pageSize;
int pageNumber;
int totalSize;
std::vector<ApplicationList> result;
};
ListAlarmHistoriesResult();
explicit ListAlarmHistoriesResult(const std::string &payload);
~ListAlarmHistoriesResult();
std::string getHttpCode()const;
int getTotalCount()const;
GetApplicationListResult();
explicit GetApplicationListResult(const std::string &payload);
~GetApplicationListResult();
std::string getMessage()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<AlarmHistoryModel> getData()const;
std::string getErrorCode()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string httpCode_;
int totalCount_;
std::string message_;
int pageSize_;
int pageNumber_;
std::vector<AlarmHistoryModel> data_;
std::string errorCode_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESRESULT_H_
#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTRESULT_H_

21
mse/include/alibabacloud/mse/model/DeleteAlarmRuleRequest.h → mse/include/alibabacloud/mse/model/GetDashBoardUrlRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_DELETEALARMRULEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_DELETEALARMRULEREQUEST_H_
#ifndef ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,23 +26,26 @@
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT DeleteAlarmRuleRequest : public RpcServiceRequest {
class ALIBABACLOUD_MSE_EXPORT GetDashBoardUrlRequest : public RpcServiceRequest {
public:
DeleteAlarmRuleRequest();
~DeleteAlarmRuleRequest();
std::string getAlarmRuleId() const;
void setAlarmRuleId(const std::string &alarmRuleId);
GetDashBoardUrlRequest();
~GetDashBoardUrlRequest();
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getRequestPars() const;
void setRequestPars(const std::string &requestPars);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string alarmRuleId_;
std::string instanceId_;
std::string regionId_;
std::string requestPars_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_DELETEALARMRULEREQUEST_H_
#endif // !ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLREQUEST_H_

21
mse/include/alibabacloud/mse/model/DeleteAlarmRuleResult.h → mse/include/alibabacloud/mse/model/GetDashBoardUrlResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_DELETEALARMRULERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_DELETEALARMRULERESULT_H_
#ifndef ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLRESULT_H_
#include <string>
#include <vector>
@@ -29,16 +29,22 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT DeleteAlarmRuleResult : public ServiceResult
class ALIBABACLOUD_MSE_EXPORT GetDashBoardUrlResult : public ServiceResult
{
public:
struct Data
{
std::string message;
std::string urlMap;
};
DeleteAlarmRuleResult();
explicit DeleteAlarmRuleResult(const std::string &payload);
~DeleteAlarmRuleResult();
GetDashBoardUrlResult();
explicit GetDashBoardUrlResult(const std::string &payload);
~GetDashBoardUrlResult();
std::string getHttpCode()const;
std::string getMessage()const;
Data getData()const;
std::string getErrorCode()const;
bool getSuccess()const;
@@ -47,6 +53,7 @@ namespace AlibabaCloud
private:
std::string httpCode_;
std::string message_;
Data data_;
std::string errorCode_;
bool success_;
@@ -54,4 +61,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_DELETEALARMRULERESULT_H_
#endif // !ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLRESULT_H_

2
mse/include/alibabacloud/mse/model/GetGatewayDomainDetailResult.h
View File

@@ -45,7 +45,7 @@ namespace AlibabaCloud
std::string gatewayUniqueId;
std::string gmtCreate;
std::string sans;
int certIdentifier;
std::string certIdentifier;
long id;
std::string certName;
std::string protocol;

1
mse/include/alibabacloud/mse/model/GetGatewayOptionResult.h
View File

@@ -45,6 +45,7 @@ namespace AlibabaCloud
std::string projectName;
bool logEnabled;
};
bool enableWaf;
bool disableHttp2Alpn;
TraceDetails traceDetails;
LogConfigDetails logConfigDetails;

1
mse/include/alibabacloud/mse/model/GetGatewayRouteDetailResult.h
View File

@@ -145,6 +145,7 @@ namespace AlibabaCloud
std::string gatewayUniqueId;
std::string services;
std::string gmtCreate;
bool enableWaf;
int routeOrder;
long domainId;
Retry retry;

73
mse/include/alibabacloud/mse/model/ListAlarmRulesResult.h
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.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMRULESRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMRULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListAlarmRulesResult : public ServiceResult
{
public:
struct AlarmRuleModel
{
std::string alarmRuleId;
std::string alarmName;
std::string alarmRuleDetail;
std::string createTime;
std::string alarmStatus;
};
ListAlarmRulesResult();
explicit ListAlarmRulesResult(const std::string &payload);
~ListAlarmRulesResult();
std::string getHttpCode()const;
int getTotalCount()const;
std::string getMessage()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<AlarmRuleModel> getData()const;
std::string getErrorCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string httpCode_;
int totalCount_;
std::string message_;
int pageSize_;
int pageNumber_;
std::vector<AlarmRuleModel> data_;
std::string errorCode_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMRULESRESULT_H_

27
mse/include/alibabacloud/mse/model/ListAlarmRulesRequest.h → mse/include/alibabacloud/mse/model/ListClusterDetailFeatureRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMRULESREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMRULESREQUEST_H_
#ifndef ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATUREREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATUREREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,29 +26,26 @@
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListAlarmRulesRequest : public RpcServiceRequest {
class ALIBABACLOUD_MSE_EXPORT ListClusterDetailFeatureRequest : public RpcServiceRequest {
public:
ListAlarmRulesRequest();
~ListAlarmRulesRequest();
std::string getAlarmMseType() const;
void setAlarmMseType(const std::string &alarmMseType);
int getPageNum() const;
void setPageNum(int pageNum);
ListClusterDetailFeatureRequest();
~ListClusterDetailFeatureRequest();
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getRequestPars() const;
void setRequestPars(const std::string &requestPars);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string alarmMseType_;
int pageNum_;
std::string instanceId_;
std::string regionId_;
std::string requestPars_;
int pageSize_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMRULESREQUEST_H_
#endif // !ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATUREREQUEST_H_

34
mse/include/alibabacloud/mse/model/ListAlarmItemsResult.h → mse/include/alibabacloud/mse/model/ListClusterDetailFeatureResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSRESULT_H_
#ifndef ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATURERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATURERESULT_H_
#include <string>
#include <vector>
@@ -29,26 +29,25 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListAlarmItemsResult : public ServiceResult
class ALIBABACLOUD_MSE_EXPORT ListClusterDetailFeatureResult : public ServiceResult
{
public:
struct AlarmItem
struct DataItem
{
std::string alarmDesc;
std::string alarmCode;
std::string clusterType;
std::string featureId;
std::string status;
std::string message;
std::string orderNum;
std::string extend;
};
ListAlarmItemsResult();
explicit ListAlarmItemsResult(const std::string &payload);
~ListAlarmItemsResult();
ListClusterDetailFeatureResult();
explicit ListClusterDetailFeatureResult(const std::string &payload);
~ListClusterDetailFeatureResult();
std::string getHttpCode()const;
int getTotalCount()const;
std::string getMessage()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<AlarmItem> getData()const;
std::vector<DataItem> getData()const;
std::string getErrorCode()const;
bool getSuccess()const;
@@ -56,11 +55,8 @@ namespace AlibabaCloud
void parse(const std::string &payload);
private:
std::string httpCode_;
int totalCount_;
std::string message_;
int pageSize_;
int pageNumber_;
std::vector<AlarmItem> data_;
std::vector<DataItem> data_;
std::string errorCode_;
bool success_;
@@ -68,4 +64,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSRESULT_H_
#endif // !ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATURERESULT_H_

1
mse/include/alibabacloud/mse/model/ListClustersResult.h
View File

@@ -34,6 +34,7 @@ namespace AlibabaCloud
public:
struct ClusterForListModel
{
std::string mseVersion;
std::string internetAddress;
std::string instanceId;
std::string clusterId;

3
mse/include/alibabacloud/mse/model/ListGatewayDomainRequest.h
View File

@@ -32,11 +32,14 @@ public:
~ListGatewayDomainRequest();
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getType() const;
void setType(const std::string &type);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string gatewayUniqueId_;
std::string type_;
std::string acceptLanguage_;
};
} // namespace Model

7
mse/include/alibabacloud/mse/model/ListGatewayDomainResult.h
View File

@@ -34,7 +34,14 @@ namespace AlibabaCloud
public:
struct Domains
{
struct Comment
{
std::string status;
};
int status;
Comment comment;
std::string gmtCreate;
std::string type;
bool mustHttps;
std::string gmtModified;
std::string certIdentifier;

8
mse/include/alibabacloud/mse/model/ListGatewayResult.h
View File

@@ -36,6 +36,11 @@ namespace AlibabaCloud
{
struct Gateways
{
struct InitConfig
{
bool enableWaf;
bool supportWaf;
};
struct SlbItem
{
std::string slbId;
@@ -66,10 +71,12 @@ namespace AlibabaCloud
std::string gatewayType;
bool upgrade;
std::string name;
std::string appVersion;
std::string statusDesc;
bool armsOn;
std::vector<Gateways::InternetSlbItem> internetSlb;
int status;
bool supportWasm;
bool mustUpgrade;
std::string instanceId;
bool ahasOn;
@@ -79,6 +86,7 @@ namespace AlibabaCloud
std::string gmtCreate;
std::string latestVersion;
std::string chargeType;
InitConfig initConfig;
std::string region;
std::string primaryUser;
long id;

1
mse/include/alibabacloud/mse/model/ListGatewayRouteRequest.h
View File

@@ -33,6 +33,7 @@ public:
int routeOrder;
std::string gatewayUniqueId;
std::string name;
std::string domainName;
long gatewayId;
long domainId;
int status;

7
mse/include/alibabacloud/mse/model/ListGatewayRouteResult.h
View File

@@ -72,6 +72,10 @@ namespace AlibabaCloud
std::string host;
int code;
};
struct Comment
{
std::string status;
};
struct RouteServicesItem
{
std::string groupName;
@@ -85,6 +89,7 @@ namespace AlibabaCloud
};
int status;
std::string defaultServiceName;
Comment comment;
std::string domainName;
std::string gmtModified;
long defaultServiceId;
@@ -97,6 +102,8 @@ namespace AlibabaCloud
std::string services;
std::vector<std::string> domainIdList;
std::string gmtCreate;
std::string type;
std::string enableWaf;
int routeOrder;
long domainId;
std::vector<std::string> domainNameList;

1
mse/include/alibabacloud/mse/model/ListGatewayServiceResult.h
View File

@@ -46,6 +46,7 @@ namespace AlibabaCloud
long sourceId;
std::string metaInfo;
std::string gmtModified;
std::string healehStatus;
std::string _namespace;
long gatewayId;
std::vector<std::string> ips;

48
mse/include/alibabacloud/mse/model/ListInstancesRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTINSTANCESREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTINSTANCESREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListInstancesRequest : public RpcServiceRequest {
public:
ListInstancesRequest();
~ListInstancesRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::string userId_;
std::string acceptLanguage_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTINSTANCESREQUEST_H_

93
mse/include/alibabacloud/mse/model/ListInstancesResult.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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_MSE_MODEL_LISTINSTANCESRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTINSTANCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListInstancesResult : public ServiceResult
{
public:
struct Instance
{
std::string dbPassword;
std::string podCidr;
std::string gmtModified;
std::string vpc;
std::string storeMode;
std::string appClusterId;
std::string name;
std::string appVersion;
bool isCreatedRedis;
std::string startDate;
std::string statusDesc;
long environmentId;
std::string vswitch;
std::string dbUrl;
std::string dbUserName;
long status;
std::string zoneId;
std::string instanceId;
std::string nameServer;
std::string orderId;
std::string securityGroup;
long endDate;
long replica;
std::string seataServerUniqueId;
std::string gmtCreate;
std::string imageVersion;
long k8sResourceId;
std::string primaryUser;
std::string region;
long id;
std::string spec;
};
ListInstancesResult();
explicit ListInstancesResult(const std::string &payload);
~ListInstancesResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::vector<Instance> getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::vector<Instance> data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTINSTANCESRESULT_H_

1
mse/include/alibabacloud/mse/model/ListListenersByConfigResult.h
View File

@@ -34,6 +34,7 @@ namespace AlibabaCloud
public:
struct Listener
{
std::string status;
std::string ip;
std::string md5;
};

45
mse/include/alibabacloud/mse/model/ListSecurityGroupRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListSecurityGroupRequest : public RpcServiceRequest {
public:
ListSecurityGroupRequest();
~ListSecurityGroupRequest();
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string gatewayUniqueId_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPREQUEST_H_

66
mse/include/alibabacloud/mse/model/ListSecurityGroupResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListSecurityGroupResult : public ServiceResult
{
public:
struct Sgs
{
std::string securityGroupName;
std::string vpcId;
std::string securityGroupId;
std::string securityGroupType;
};
ListSecurityGroupResult();
explicit ListSecurityGroupResult(const std::string &payload);
~ListSecurityGroupResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::vector<Sgs> getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::vector<Sgs> data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRESULT_H_

45
mse/include/alibabacloud/mse/model/ListSecurityGroupRuleRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT ListSecurityGroupRuleRequest : public RpcServiceRequest {
public:
ListSecurityGroupRuleRequest();
~ListSecurityGroupRuleRequest();
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
std::string gatewayUniqueId_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULEREQUEST_H_

71
mse/include/alibabacloud/mse/model/ListSecurityGroupRuleResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULERESULT_H_
#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT ListSecurityGroupRuleResult : public ServiceResult
{
public:
struct Rules
{
std::string gatewayUniqueId;
std::string portRange;
std::string gmtCreate;
std::string description;
std::string securityGroupId;
std::string gmtModified;
std::string ipProtocol;
std::string id;
long gatewayId;
};
ListSecurityGroupRuleResult();
explicit ListSecurityGroupRuleResult(const std::string &payload);
~ListSecurityGroupRuleResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::vector<Rules> getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::vector<Rules> data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULERESULT_H_

7
mse/include/alibabacloud/mse/model/ListServiceSourceResult.h
View File

@@ -34,8 +34,15 @@ namespace AlibabaCloud
public:
struct Sources
{
struct IngressOptions
{
std::string ingressClass;
std::string watchNamespace;
bool enableIngress;
};
std::string type;
std::string gmtCreate;
IngressOptions ingressOptions;
std::string sourceUniqueId;
std::string address;
std::string gmtModified;

3
mse/include/alibabacloud/mse/model/PullServicesRequest.h
View File

@@ -30,8 +30,6 @@ class ALIBABACLOUD_MSE_EXPORT PullServicesRequest : public RpcServiceRequest {
public:
PullServicesRequest();
~PullServicesRequest();
std::string getSourceId() const;
void setSourceId(const std::string &sourceId);
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
std::string getAcceptLanguage() const;
@@ -40,7 +38,6 @@ public:
void setSourceType(const std::string &sourceType);
private:
std::string sourceId_;
std::string gatewayUniqueId_;
std::string acceptLanguage_;
std::string sourceType_;

1
mse/include/alibabacloud/mse/model/PullServicesResult.h
View File

@@ -44,6 +44,7 @@ namespace AlibabaCloud
};
std::string groupName;
std::vector<PullServices::ServicesItem> services;
std::string namespaceShowName;
std::string _namespace;
};

3
mse/include/alibabacloud/mse/model/QueryClusterDetailRequest.h
View File

@@ -30,6 +30,8 @@ class ALIBABACLOUD_MSE_EXPORT QueryClusterDetailRequest : public RpcServiceReque
public:
QueryClusterDetailRequest();
~QueryClusterDetailRequest();
bool getAclSwitch() const;
void setAclSwitch(bool aclSwitch);
std::string getOrderId() const;
void setOrderId(const std::string &orderId);
std::string getClusterId() const;
@@ -40,6 +42,7 @@ public:
void setAcceptLanguage(const std::string &acceptLanguage);
private:
bool aclSwitch_;
std::string orderId_;
std::string clusterId_;
std::string instanceId_;

1
mse/include/alibabacloud/mse/model/QueryClusterDetailResult.h
View File

@@ -41,6 +41,7 @@ namespace AlibabaCloud
std::string internetIp;
std::string creationTimestamp;
std::string singleTunnelVip;
std::string zone;
std::string ip;
std::string healthStatus;
};

48
mse/include/alibabacloud/mse/model/QueryUserVpcRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT QueryUserVpcRequest : public RpcServiceRequest {
public:
QueryUserVpcRequest();
~QueryUserVpcRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::string userId_;
std::string acceptLanguage_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCREQUEST_H_

71
mse/include/alibabacloud/mse/model/QueryUserVpcResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT QueryUserVpcResult : public ServiceResult
{
public:
struct Vpcs
{
struct VSwitchListItem
{
std::string zoneId;
std::string vswitchName;
std::string vswitchId;
};
std::string vpcId;
std::vector<Vpcs::VSwitchListItem> vSwitchList;
std::string vpcName;
};
QueryUserVpcResult();
explicit QueryUserVpcResult(const std::string &payload);
~QueryUserVpcResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::vector<Vpcs> getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::vector<Vpcs> data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCRESULT_H_

3
mse/include/alibabacloud/mse/model/QueryZnodeDetailRequest.h
View File

@@ -34,6 +34,8 @@ public:
void setClusterId(const std::string &clusterId);
std::string getPath() const;
void setPath(const std::string &path);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getRequestPars() const;
void setRequestPars(const std::string &requestPars);
std::string getAcceptLanguage() const;
@@ -42,6 +44,7 @@ public:
private:
std::string clusterId_;
std::string path_;
std::string instanceId_;
std::string requestPars_;
std::string acceptLanguage_;
};

45
mse/include/alibabacloud/mse/model/RestartSeataServerRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT RestartSeataServerRequest : public RpcServiceRequest {
public:
RestartSeataServerRequest();
~RestartSeataServerRequest();
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getSeataServerUniqueId() const;
void setSeataServerUniqueId(const std::string &seataServerUniqueId);
private:
std::string acceptLanguage_;
std::string seataServerUniqueId_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERREQUEST_H_

59
mse/include/alibabacloud/mse/model/RestartSeataServerResult.h Normal file
View File

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

1
mse/include/alibabacloud/mse/model/UpdateGatewayOptionRequest.h
View File

@@ -29,6 +29,7 @@ namespace Model {
class ALIBABACLOUD_MSE_EXPORT UpdateGatewayOptionRequest : public RpcServiceRequest {
public:
struct GatewayOption {
bool enableWaf;
bool enableHardwareAcceleration;
bool disableHttp2Alpn;
struct LogConfigDetails {

1
mse/include/alibabacloud/mse/model/UpdateGatewayOptionResult.h
View File

@@ -45,6 +45,7 @@ namespace AlibabaCloud
std::string projectName;
bool logEnabled;
};
bool enableWaf;
bool disableHttp2Alpn;
TraceDetails traceDetails;
LogConfigDetails logConfigDetails;

3
mse/include/alibabacloud/mse/model/UpdateGatewayRouteRequest.h
View File

@@ -84,6 +84,8 @@ public:
void setGatewayId(long gatewayId);
int getRouteOrder() const;
void setRouteOrder(int routeOrder);
bool getEnableWaf() const;
void setEnableWaf(bool enableWaf);
std::vector<Services> getServices() const;
void setServices(const std::vector<Services> &services);
Predicates getPredicates() const;
@@ -104,6 +106,7 @@ private:
long id_;
long gatewayId_;
int routeOrder_;
bool enableWaf_;
std::vector<Services> services_;
Predicates predicates_;
RedirectJSON redirectJSON_;

51
mse/include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteWafStatusRequest : public RpcServiceRequest {
public:
UpdateGatewayRouteWafStatusRequest();
~UpdateGatewayRouteWafStatusRequest();
bool getEnableWaf() const;
void setEnableWaf(bool enableWaf);
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
long getRouteId() const;
void setRouteId(long routeId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private:
bool enableWaf_;
std::string gatewayUniqueId_;
long routeId_;
std::string acceptLanguage_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSREQUEST_H_

181
mse/include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusResult.h Normal file
View File

@@ -0,0 +1,181 @@
/*
* 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_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteWafStatusResult : public ServiceResult
{
public:
struct Data
{
struct RoutePredicates
{
struct PathPredicates
{
std::string path;
std::string type;
bool ignoreCase;
};
struct HeaderPredicatesItem
{
std::string type;
std::string value;
std::string key;
};
struct QueryPredicatesItem
{
std::string type;
std::string value;
std::string key;
};
std::vector<HeaderPredicatesItem> headerPredicates;
std::vector<std::string> methodPredicates;
std::vector<QueryPredicatesItem> queryPredicates;
PathPredicates pathPredicates;
};
struct HTTPRewrite
{
std::string status;
std::string path;
std::string pathType;
std::string pattern;
std::string substitution;
std::string host;
};
struct HeaderOp
{
struct HeaderOpItemsItem
{
std::string directionType;
std::string value;
std::string opType;
std::string key;
};
std::string status;
std::vector<HeaderOpItemsItem> headerOpItems;
};
struct DirectResponse
{
int code;
std::string body;
};
struct Cors
{
std::string status;
std::string allowOrigins;
bool allowCredentials;
std::string exposeHeaders;
long unitNum;
std::string allowHeaders;
std::string timeUnit;
std::string allowMethods;
};
struct Timeout
{
std::string status;
int unitNum;
std::string timeUnit;
};
struct Retry
{
std::string status;
std::vector<std::string> httpCodes;
int attempts;
std::vector<std::string> retryOn;
};
struct Redirect
{
std::string path;
std::string host;
int code;
};
struct RouteServicesItem
{
std::string groupName;
std::string serviceName;
int percent;
std::string version;
std::string sourceType;
std::string _namespace;
long serviceId;
std::string name;
};
std::string gmtModified;
std::string destinationType;
HeaderOp headerOp;
std::string name;
std::vector<std::string> domainIdList;
std::vector<std::string> domainNameList;
DirectResponse directResponse;
std::string defaultServiceName;
int status;
std::string domainName;
Timeout timeout;
long defaultServiceId;
RoutePredicates routePredicates;
Redirect redirect;
long gatewayId;
Cors cors;
std::string gatewayUniqueId;
std::string services;
std::string gmtCreate;
bool enableWaf;
int routeOrder;
long domainId;
Retry retry;
long id;
HTTPRewrite hTTPRewrite;
std::string predicates;
std::vector<RouteServicesItem> routeServices;
};
UpdateGatewayRouteWafStatusResult();
explicit UpdateGatewayRouteWafStatusResult(const std::string &payload);
~UpdateGatewayRouteWafStatusResult();
std::string getMessage()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSRESULT_H_

78
mse/include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT UpdateGatewayServiceTrafficPolicyRequest : public RpcServiceRequest {
public:
struct GatewayTrafficPolicy {
struct TlsSetting {
std::string tlsMode;
std::string caCertContent;
std::string certId;
std::string sni;
};
TlsSetting tlsSetting;
struct LoadBalancerSettings {
std::string loadbalancerType;
struct ConsistentHashLBConfig {
struct HttpCookie {
std::string path;
std::string name;
std::string tTL;
};
HttpCookie httpCookie;
std::string parameterName;
std::string consistentHashLBType;
};
ConsistentHashLBConfig consistentHashLBConfig;
};
LoadBalancerSettings loadBalancerSettings;
};
UpdateGatewayServiceTrafficPolicyRequest();
~UpdateGatewayServiceTrafficPolicyRequest();
std::string getGatewayUniqueId() const;
void setGatewayUniqueId(const std::string &gatewayUniqueId);
GatewayTrafficPolicy getGatewayTrafficPolicy() const;
void setGatewayTrafficPolicy(const GatewayTrafficPolicy &gatewayTrafficPolicy);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
long getServiceId() const;
void setServiceId(long serviceId);
long getGatewayId() const;
void setGatewayId(long gatewayId);
private:
std::string gatewayUniqueId_;
GatewayTrafficPolicy gatewayTrafficPolicy_;
std::string acceptLanguage_;
long serviceId_;
long gatewayId_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYREQUEST_H_

99
mse/include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyResult.h Normal file
View File

@@ -0,0 +1,99 @@
/*
* 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_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYRESULT_H_
#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/mse/MseExport.h>
namespace AlibabaCloud
{
namespace Mse
{
namespace Model
{
class ALIBABACLOUD_MSE_EXPORT UpdateGatewayServiceTrafficPolicyResult : public ServiceResult
{
public:
struct Data
{
struct GatewayTrafficPolicy
{
struct TlsSetting
{
std::string certId;
std::string caCertContent;
std::string tlsMode;
std::string sni;
};
struct LoadBalancerSettings
{
struct ConsistentHashLBConfig
{
struct HttpCookie
{
std::string path;
std::string tTL;
std::string name;
};
std::string consistentHashLBType;
std::string parameterName;
HttpCookie httpCookie;
};
ConsistentHashLBConfig consistentHashLBConfig;
std::string loadbalancerType;
};
TlsSetting tlsSetting;
LoadBalancerSettings loadBalancerSettings;
};
std::string groupName;
std::string gatewayUniqueId;
std::string sourceType;
std::string metaInfo;
std::string _namespace;
long id;
GatewayTrafficPolicy gatewayTrafficPolicy;
std::string name;
};
UpdateGatewayServiceTrafficPolicyResult();
explicit UpdateGatewayServiceTrafficPolicyResult(const std::string &payload);
~UpdateGatewayServiceTrafficPolicyResult();
std::string getMessage()const;
int getHttpStatusCode()const;
Data getData()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
Data data_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYRESULT_H_

54
mse/include/alibabacloud/mse/model/UpdateMessageQueueRouteRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTEREQUEST_H_
#define ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTEREQUEST_H_
#include <alibabacloud/mse/MseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Mse {
namespace Model {
class ALIBABACLOUD_MSE_EXPORT UpdateMessageQueueRouteRequest : public RpcServiceRequest {
public:
UpdateMessageQueueRouteRequest();
~UpdateMessageQueueRouteRequest();
std::vector<std::string> getTags() const;
void setTags(const std::vector<std::string> &tags);
bool getEnable() const;
void setEnable(bool enable);
std::string getAppId() const;
void setAppId(const std::string &appId);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::vector<std::string> tags_;
bool enable_;
std::string appId_;
std::string acceptLanguage_;
std::string region_;
};
} // namespace Model
} // namespace Mse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTEREQUEST_H_

59
mse/include/alibabacloud/mse/model/UpdateMessageQueueRouteResult.h Normal file
View File

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

978
mse/src/MseClient.cc
View File

File diff suppressed because it is too large Load Diff

9
mse/src/model/AddGatewayRouteRequest.cc
View File

@@ -79,6 +79,15 @@ void AddGatewayRouteRequest::setRouteOrder(int routeOrder) {
setParameter(std::string("RouteOrder"), std::to_string(routeOrder));
}
bool AddGatewayRouteRequest::getEnableWaf() const {
return enableWaf_;
}
void AddGatewayRouteRequest::setEnableWaf(bool enableWaf) {
enableWaf_ = enableWaf;
setParameter(std::string("EnableWaf"), enableWaf ? "true" : "false");
}
std::vector<AddGatewayRouteRequest::Services> AddGatewayRouteRequest::getServices() const {
return services_;
}

2
mse/src/model/AddSSLCertRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::AddSSLCertRequest;
AddSSLCertRequest::AddSSLCertRequest()
: RpcServiceRequest("mse", "2019-05-31", "AddSSLCert") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
AddSSLCertRequest::~AddSSLCertRequest() {}

99
mse/src/model/AddSeataServerRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* 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/mse/model/AddSeataServerRequest.h>
using AlibabaCloud::Mse::Model::AddSeataServerRequest;
AddSeataServerRequest::AddSeataServerRequest()
: RpcServiceRequest("mse", "2019-05-31", "AddSeataServer") {
setMethod(HttpRequest::Method::Post);
}
AddSeataServerRequest::~AddSeataServerRequest() {}
int AddSeataServerRequest::getReplica() const {
return replica_;
}
void AddSeataServerRequest::setReplica(int replica) {
replica_ = replica;
setParameter(std::string("Replica"), std::to_string(replica));
}
std::string AddSeataServerRequest::getPrimaryUser() const {
return primaryUser_;
}
void AddSeataServerRequest::setPrimaryUser(const std::string &primaryUser) {
primaryUser_ = primaryUser;
setParameter(std::string("PrimaryUser"), primaryUser);
}
std::string AddSeataServerRequest::getVpc() const {
return vpc_;
}
void AddSeataServerRequest::setVpc(const std::string &vpc) {
vpc_ = vpc;
setParameter(std::string("Vpc"), vpc);
}
std::string AddSeataServerRequest::getVswitch() const {
return vswitch_;
}
void AddSeataServerRequest::setVswitch(const std::string &vswitch) {
vswitch_ = vswitch;
setParameter(std::string("Vswitch"), vswitch);
}
std::string AddSeataServerRequest::getName() const {
return name_;
}
void AddSeataServerRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string AddSeataServerRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void AddSeataServerRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string AddSeataServerRequest::getZoneId() const {
return zoneId_;
}
void AddSeataServerRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string AddSeataServerRequest::getRegion() const {
return region_;
}
void AddSeataServerRequest::setRegion(const std::string &region) {
region_ = region;
setParameter(std::string("Region"), region);
}

79
mse/src/model/AddSeataServerResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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/mse/model/AddSeataServerResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
AddSeataServerResult::AddSeataServerResult() :
ServiceResult()
{}
AddSeataServerResult::AddSeataServerResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddSeataServerResult::~AddSeataServerResult()
{}
void AddSeataServerResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string AddSeataServerResult::getMessage()const
{
return message_;
}
int AddSeataServerResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string AddSeataServerResult::getData()const
{
return data_;
}
int AddSeataServerResult::getCode()const
{
return code_;
}
bool AddSeataServerResult::getSuccess()const
{
return success_;
}

72
mse/src/model/AddSecurityGroupRuleRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mse/model/AddSecurityGroupRuleRequest.h>
using AlibabaCloud::Mse::Model::AddSecurityGroupRuleRequest;
AddSecurityGroupRuleRequest::AddSecurityGroupRuleRequest()
: RpcServiceRequest("mse", "2019-05-31", "AddSecurityGroupRule") {
setMethod(HttpRequest::Method::Post);
}
AddSecurityGroupRuleRequest::~AddSecurityGroupRuleRequest() {}
std::string AddSecurityGroupRuleRequest::getPortRange() const {
return portRange_;
}
void AddSecurityGroupRuleRequest::setPortRange(const std::string &portRange) {
portRange_ = portRange;
setParameter(std::string("PortRange"), portRange);
}
std::string AddSecurityGroupRuleRequest::getGatewayUniqueId() const {
return gatewayUniqueId_;
}
void AddSecurityGroupRuleRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
gatewayUniqueId_ = gatewayUniqueId;
setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
}
std::string AddSecurityGroupRuleRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void AddSecurityGroupRuleRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string AddSecurityGroupRuleRequest::getDescription() const {
return description_;
}
void AddSecurityGroupRuleRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string AddSecurityGroupRuleRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void AddSecurityGroupRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}

79
mse/src/model/AddSecurityGroupRuleResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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/mse/model/AddSecurityGroupRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
AddSecurityGroupRuleResult::AddSecurityGroupRuleResult() :
ServiceResult()
{}
AddSecurityGroupRuleResult::AddSecurityGroupRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddSecurityGroupRuleResult::~AddSecurityGroupRuleResult()
{}
void AddSecurityGroupRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string AddSecurityGroupRuleResult::getMessage()const
{
return message_;
}
int AddSecurityGroupRuleResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string AddSecurityGroupRuleResult::getData()const
{
return data_;
}
int AddSecurityGroupRuleResult::getCode()const
{
return code_;
}
bool AddSecurityGroupRuleResult::getSuccess()const
{
return success_;
}

11
mse/src/model/AddServiceSourceRequest.cc
View File

@@ -25,6 +25,17 @@ AddServiceSourceRequest::AddServiceSourceRequest()
AddServiceSourceRequest::~AddServiceSourceRequest() {}
AddServiceSourceRequest::IngressOptionsRequest AddServiceSourceRequest::getIngressOptionsRequest() const {
return ingressOptionsRequest_;
}
void AddServiceSourceRequest::setIngressOptionsRequest(const AddServiceSourceRequest::IngressOptionsRequest &ingressOptionsRequest) {
ingressOptionsRequest_ = ingressOptionsRequest;
setParameter(std::string("IngressOptionsRequest") + ".EnableIngress", ingressOptionsRequest.enableIngress ? "true" : "false");
setParameter(std::string("IngressOptionsRequest") + ".WatchNamespace", ingressOptionsRequest.watchNamespace);
setParameter(std::string("IngressOptionsRequest") + ".IngressClass", ingressOptionsRequest.ingressClass);
}
std::string AddServiceSourceRequest::getGatewayUniqueId() const {
return gatewayUniqueId_;
}

72
mse/src/model/AddTestRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mse/model/AddTestRequest.h>
using AlibabaCloud::Mse::Model::AddTestRequest;
AddTestRequest::AddTestRequest()
: RpcServiceRequest("mse", "2019-05-31", "AddTest") {
setMethod(HttpRequest::Method::Post);
}
AddTestRequest::~AddTestRequest() {}
int AddTestRequest::getPageNumber() const {
return pageNumber_;
}
void AddTestRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string AddTestRequest::getOrderItem() const {
return orderItem_;
}
void AddTestRequest::setOrderItem(const std::string &orderItem) {
orderItem_ = orderItem;
setParameter(std::string("OrderItem"), orderItem);
}
int AddTestRequest::getPageSize() const {
return pageSize_;
}
void AddTestRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string AddTestRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void AddTestRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
bool AddTestRequest::getDescSort() const {
return descSort_;
}
void AddTestRequest::setDescSort(bool descSort) {
descSort_ = descSort;
setParameter(std::string("DescSort"), descSort ? "true" : "false");
}

182
mse/src/model/AddTestResult.cc Normal file
View File

@@ -0,0 +1,182 @@
/*
* 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/mse/model/AddTestResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
AddTestResult::AddTestResult() :
ServiceResult()
{}
AddTestResult::AddTestResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddTestResult::~AddTestResult()
{}
void AddTestResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["TotalSize"].isNull())
data_.totalSize = std::stol(dataNode["TotalSize"].asString());
if(!dataNode["PageNumber"].isNull())
data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
if(!dataNode["PageSize"].isNull())
data_.pageSize = std::stoi(dataNode["PageSize"].asString());
auto allResultNode = dataNode["Result"]["Gateways"];
for (auto dataNodeResultGateways : allResultNode)
{
Data::Gateways gatewaysObject;
if(!dataNodeResultGateways["Id"].isNull())
gatewaysObject.id = std::stol(dataNodeResultGateways["Id"].asString());
if(!dataNodeResultGateways["Name"].isNull())
gatewaysObject.name = dataNodeResultGateways["Name"].asString();
if(!dataNodeResultGateways["GatewayUniqueId"].isNull())
gatewaysObject.gatewayUniqueId = dataNodeResultGateways["GatewayUniqueId"].asString();
if(!dataNodeResultGateways["GatewayType"].isNull())
gatewaysObject.gatewayType = dataNodeResultGateways["GatewayType"].asString();
if(!dataNodeResultGateways["Region"].isNull())
gatewaysObject.region = dataNodeResultGateways["Region"].asString();
if(!dataNodeResultGateways["PrimaryUser"].isNull())
gatewaysObject.primaryUser = dataNodeResultGateways["PrimaryUser"].asString();
if(!dataNodeResultGateways["Status"].isNull())
gatewaysObject.status = std::stoi(dataNodeResultGateways["Status"].asString());
if(!dataNodeResultGateways["AhasOn"].isNull())
gatewaysObject.ahasOn = dataNodeResultGateways["AhasOn"].asString() == "true";
if(!dataNodeResultGateways["ArmsOn"].isNull())
gatewaysObject.armsOn = dataNodeResultGateways["ArmsOn"].asString() == "true";
if(!dataNodeResultGateways["Spec"].isNull())
gatewaysObject.spec = dataNodeResultGateways["Spec"].asString();
if(!dataNodeResultGateways["Replica"].isNull())
gatewaysObject.replica = std::stoi(dataNodeResultGateways["Replica"].asString());
if(!dataNodeResultGateways["GmtCreate"].isNull())
gatewaysObject.gmtCreate = dataNodeResultGateways["GmtCreate"].asString();
if(!dataNodeResultGateways["GmtModified"].isNull())
gatewaysObject.gmtModified = dataNodeResultGateways["GmtModified"].asString();
if(!dataNodeResultGateways["StatusDesc"].isNull())
gatewaysObject.statusDesc = dataNodeResultGateways["StatusDesc"].asString();
if(!dataNodeResultGateways["Upgrade"].isNull())
gatewaysObject.upgrade = dataNodeResultGateways["Upgrade"].asString() == "true";
if(!dataNodeResultGateways["MustUpgrade"].isNull())
gatewaysObject.mustUpgrade = dataNodeResultGateways["MustUpgrade"].asString() == "true";
if(!dataNodeResultGateways["CurrentVersion"].isNull())
gatewaysObject.currentVersion = dataNodeResultGateways["CurrentVersion"].asString();
if(!dataNodeResultGateways["LatestVersion"].isNull())
gatewaysObject.latestVersion = dataNodeResultGateways["LatestVersion"].asString();
if(!dataNodeResultGateways["Vswitch2"].isNull())
gatewaysObject.vswitch2 = dataNodeResultGateways["Vswitch2"].asString();
if(!dataNodeResultGateways["InstanceId"].isNull())
gatewaysObject.instanceId = dataNodeResultGateways["InstanceId"].asString();
if(!dataNodeResultGateways["ChargeType"].isNull())
gatewaysObject.chargeType = dataNodeResultGateways["ChargeType"].asString();
if(!dataNodeResultGateways["EndDate"].isNull())
gatewaysObject.endDate = dataNodeResultGateways["EndDate"].asString();
if(!dataNodeResultGateways["Tag"].isNull())
gatewaysObject.tag = dataNodeResultGateways["Tag"].asString();
auto allSlbNode = dataNodeResultGateways["Slb"]["slbItem"];
for (auto dataNodeResultGatewaysSlbslbItem : allSlbNode)
{
Data::Gateways::SlbItem slbObject;
if(!dataNodeResultGatewaysSlbslbItem["SlbIp"].isNull())
slbObject.slbIp = dataNodeResultGatewaysSlbslbItem["SlbIp"].asString();
if(!dataNodeResultGatewaysSlbslbItem["SlbPort"].isNull())
slbObject.slbPort = dataNodeResultGatewaysSlbslbItem["SlbPort"].asString();
if(!dataNodeResultGatewaysSlbslbItem["SlbSpec"].isNull())
slbObject.slbSpec = dataNodeResultGatewaysSlbslbItem["SlbSpec"].asString();
if(!dataNodeResultGatewaysSlbslbItem["Type"].isNull())
slbObject.type = dataNodeResultGatewaysSlbslbItem["Type"].asString();
if(!dataNodeResultGatewaysSlbslbItem["GatewaySlbStatus"].isNull())
slbObject.gatewaySlbStatus = dataNodeResultGatewaysSlbslbItem["GatewaySlbStatus"].asString();
if(!dataNodeResultGatewaysSlbslbItem["StatusDesc"].isNull())
slbObject.statusDesc = dataNodeResultGatewaysSlbslbItem["StatusDesc"].asString();
if(!dataNodeResultGatewaysSlbslbItem["GatewaySlbMode"].isNull())
slbObject.gatewaySlbMode = dataNodeResultGatewaysSlbslbItem["GatewaySlbMode"].asString();
if(!dataNodeResultGatewaysSlbslbItem["SlbId"].isNull())
slbObject.slbId = dataNodeResultGatewaysSlbslbItem["SlbId"].asString();
gatewaysObject.slb.push_back(slbObject);
}
auto allInternetSlbNode = dataNodeResultGateways["InternetSlb"]["internetSlbItem"];
for (auto dataNodeResultGatewaysInternetSlbinternetSlbItem : allInternetSlbNode)
{
Data::Gateways::InternetSlbItem internetSlbObject;
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbIp"].isNull())
internetSlbObject.slbIp = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbIp"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbPort"].isNull())
internetSlbObject.slbPort = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbPort"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbSpec"].isNull())
internetSlbObject.slbSpec = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbSpec"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["Type"].isNull())
internetSlbObject.type = dataNodeResultGatewaysInternetSlbinternetSlbItem["Type"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["InternetNetworkFlow"].isNull())
internetSlbObject.internetNetworkFlow = dataNodeResultGatewaysInternetSlbinternetSlbItem["InternetNetworkFlow"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbStatus"].isNull())
internetSlbObject.gatewaySlbStatus = dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbStatus"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["StatusDesc"].isNull())
internetSlbObject.statusDesc = dataNodeResultGatewaysInternetSlbinternetSlbItem["StatusDesc"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbMode"].isNull())
internetSlbObject.gatewaySlbMode = dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbMode"].asString();
if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbId"].isNull())
internetSlbObject.slbId = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbId"].asString();
gatewaysObject.internetSlb.push_back(internetSlbObject);
}
data_.result.push_back(gatewaysObject);
}
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string AddTestResult::getMessage()const
{
return message_;
}
int AddTestResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
AddTestResult::Data AddTestResult::getData()const
{
return data_;
}
int AddTestResult::getCode()const
{
return code_;
}
bool AddTestResult::getSuccess()const
{
return success_;
}

2
mse/src/model/ApplyGatewayRouteRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::ApplyGatewayRouteRequest;
ApplyGatewayRouteRequest::ApplyGatewayRouteRequest()
: RpcServiceRequest("mse", "2019-05-31", "ApplyGatewayRoute") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
ApplyGatewayRouteRequest::~ApplyGatewayRouteRequest() {}

126
mse/src/model/CreateAlarmRuleRequest.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/mse/model/CreateAlarmRuleRequest.h>
using AlibabaCloud::Mse::Model::CreateAlarmRuleRequest;
CreateAlarmRuleRequest::CreateAlarmRuleRequest()
: RpcServiceRequest("mse", "2019-05-31", "CreateAlarmRule") {
setMethod(HttpRequest::Method::Post);
}
CreateAlarmRuleRequest::~CreateAlarmRuleRequest() {}
int CreateAlarmRuleRequest::getNValue() const {
return nValue_;
}
void CreateAlarmRuleRequest::setNValue(int nValue) {
nValue_ = nValue;
setParameter(std::string("NValue"), std::to_string(nValue));
}
std::string CreateAlarmRuleRequest::getAlarmItem() const {
return alarmItem_;
}
void CreateAlarmRuleRequest::setAlarmItem(const std::string &alarmItem) {
alarmItem_ = alarmItem;
setParameter(std::string("AlarmItem"), alarmItem);
}
std::string CreateAlarmRuleRequest::getClusterId() const {
return clusterId_;
}
void CreateAlarmRuleRequest::setClusterId(const std::string &clusterId) {
clusterId_ = clusterId;
setParameter(std::string("ClusterId"), clusterId);
}
std::string CreateAlarmRuleRequest::get_Operator() const {
return _operator_;
}
void CreateAlarmRuleRequest::set_Operator(const std::string &_operator) {
_operator_ = _operator;
setParameter(std::string("Operator"), _operator);
}
std::string CreateAlarmRuleRequest::getAlarmAliasName() const {
return alarmAliasName_;
}
void CreateAlarmRuleRequest::setAlarmAliasName(const std::string &alarmAliasName) {
alarmAliasName_ = alarmAliasName;
setParameter(std::string("AlarmAliasName"), alarmAliasName);
}
std::string CreateAlarmRuleRequest::getInstanceId() const {
return instanceId_;
}
void CreateAlarmRuleRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
std::string CreateAlarmRuleRequest::getContactGroupIds() const {
return contactGroupIds_;
}
void CreateAlarmRuleRequest::setContactGroupIds(const std::string &contactGroupIds) {
contactGroupIds_ = contactGroupIds;
setParameter(std::string("ContactGroupIds"), contactGroupIds);
}
std::string CreateAlarmRuleRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void CreateAlarmRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string CreateAlarmRuleRequest::getAlertWay() const {
return alertWay_;
}
void CreateAlarmRuleRequest::setAlertWay(const std::string &alertWay) {
alertWay_ = alertWay;
setParameter(std::string("AlertWay"), alertWay);
}
std::string CreateAlarmRuleRequest::getAggregates() const {
return aggregates_;
}
void CreateAlarmRuleRequest::setAggregates(const std::string &aggregates) {
aggregates_ = aggregates;
setParameter(std::string("Aggregates"), aggregates);
}
float CreateAlarmRuleRequest::getValue() const {
return value_;
}
void CreateAlarmRuleRequest::setValue(float value) {
value_ = value;
setParameter(std::string("Value"), std::to_string(value));
}

18
mse/src/model/CreateApplicationRequest.cc
View File

@@ -61,6 +61,15 @@ void CreateApplicationRequest::setAppName(const std::string &appName) {
setParameter(std::string("AppName"), appName);
}
std::string CreateApplicationRequest::getSwitchEnable() const {
return switchEnable_;
}
void CreateApplicationRequest::setSwitchEnable(const std::string &switchEnable) {
switchEnable_ = switchEnable;
setParameter(std::string("SwitchEnable"), switchEnable);
}
std::string CreateApplicationRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
@@ -70,6 +79,15 @@ void CreateApplicationRequest::setAcceptLanguage(const std::string &acceptLangua
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string CreateApplicationRequest::getSentinelEnable() const {
return sentinelEnable_;
}
void CreateApplicationRequest::setSentinelEnable(const std::string &sentinelEnable) {
sentinelEnable_ = sentinelEnable;
setParameter(std::string("SentinelEnable"), sentinelEnable);
}
std::string CreateApplicationRequest::getRegion() const {
return region_;
}

9
mse/src/model/CreateEngineNamespaceRequest.cc
View File

@@ -70,6 +70,15 @@ void CreateEngineNamespaceRequest::setAcceptLanguage(const std::string &acceptLa
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string CreateEngineNamespaceRequest::getId() const {
return id_;
}
void CreateEngineNamespaceRequest::setId(const std::string &id) {
id_ = id;
setParameter(std::string("Id"), id);
}
std::string CreateEngineNamespaceRequest::getDesc() const {
return desc_;
}

72
mse/src/model/CreateVGroupRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mse/model/CreateVGroupRequest.h>
using AlibabaCloud::Mse::Model::CreateVGroupRequest;
CreateVGroupRequest::CreateVGroupRequest()
: RpcServiceRequest("mse", "2019-05-31", "CreateVGroup") {
setMethod(HttpRequest::Method::Post);
}
CreateVGroupRequest::~CreateVGroupRequest() {}
std::string CreateVGroupRequest::getPrimaryUser() const {
return primaryUser_;
}
void CreateVGroupRequest::setPrimaryUser(const std::string &primaryUser) {
primaryUser_ = primaryUser;
setParameter(std::string("PrimaryUser"), primaryUser);
}
std::string CreateVGroupRequest::getName() const {
return name_;
}
void CreateVGroupRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string CreateVGroupRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void CreateVGroupRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string CreateVGroupRequest::getSeataServerUniqueId() const {
return seataServerUniqueId_;
}
void CreateVGroupRequest::setSeataServerUniqueId(const std::string &seataServerUniqueId) {
seataServerUniqueId_ = seataServerUniqueId;
setParameter(std::string("SeataServerUniqueId"), seataServerUniqueId);
}
std::string CreateVGroupRequest::getRegion() const {
return region_;
}
void CreateVGroupRequest::setRegion(const std::string &region) {
region_ = region;
setParameter(std::string("Region"), region);
}

36
mse/src/model/CreateAlarmRuleResult.cc → mse/src/model/CreateVGroupResult.cc
View File

@@ -14,51 +14,65 @@
* limitations under the License.
*/
#include <alibabacloud/mse/model/CreateAlarmRuleResult.h>
#include <alibabacloud/mse/model/CreateVGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
CreateAlarmRuleResult::CreateAlarmRuleResult() :
CreateVGroupResult::CreateVGroupResult() :
ServiceResult()
{}
CreateAlarmRuleResult::CreateAlarmRuleResult(const std::string &payload) :
CreateVGroupResult::CreateVGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateAlarmRuleResult::~CreateAlarmRuleResult()
CreateVGroupResult::~CreateVGroupResult()
{}
void CreateAlarmRuleResult::parse(const std::string &payload)
void CreateVGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string CreateAlarmRuleResult::getMessage()const
std::string CreateVGroupResult::getMessage()const
{
return message_;
}
std::string CreateAlarmRuleResult::getErrorCode()const
int CreateVGroupResult::getHttpStatusCode()const
{
return errorCode_;
return httpStatusCode_;
}
bool CreateAlarmRuleResult::getSuccess()const
std::string CreateVGroupResult::getData()const
{
return data_;
}
int CreateVGroupResult::getCode()const
{
return code_;
}
bool CreateVGroupResult::getSuccess()const
{
return success_;
}

54
mse/src/model/DeleteAlarmRuleRequest.cc
View File

@@ -1,54 +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/mse/model/DeleteAlarmRuleRequest.h>
using AlibabaCloud::Mse::Model::DeleteAlarmRuleRequest;
DeleteAlarmRuleRequest::DeleteAlarmRuleRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteAlarmRule") {
setMethod(HttpRequest::Method::Post);
}
DeleteAlarmRuleRequest::~DeleteAlarmRuleRequest() {}
std::string DeleteAlarmRuleRequest::getAlarmRuleId() const {
return alarmRuleId_;
}
void DeleteAlarmRuleRequest::setAlarmRuleId(const std::string &alarmRuleId) {
alarmRuleId_ = alarmRuleId;
setParameter(std::string("AlarmRuleId"), alarmRuleId);
}
std::string DeleteAlarmRuleRequest::getRequestPars() const {
return requestPars_;
}
void DeleteAlarmRuleRequest::setRequestPars(const std::string &requestPars) {
requestPars_ = requestPars;
setParameter(std::string("RequestPars"), requestPars);
}
std::string DeleteAlarmRuleRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void DeleteAlarmRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}

2
mse/src/model/DeleteAuthResourceRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteAuthResourceRequest;
DeleteAuthResourceRequest::DeleteAuthResourceRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteAuthResource") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
DeleteAuthResourceRequest::~DeleteAuthResourceRequest() {}

2
mse/src/model/DeleteGatewayDomainRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewayDomainRequest;
DeleteGatewayDomainRequest::DeleteGatewayDomainRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayDomain") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
DeleteGatewayDomainRequest::~DeleteGatewayDomainRequest() {}

2
mse/src/model/DeleteGatewayDomainResult.cc
View File

@@ -53,7 +53,7 @@ void DeleteGatewayDomainResult::parse(const std::string &payload)
if(!dataNode["MustHttps"].isNull())
data_.mustHttps = dataNode["MustHttps"].asString() == "true";
if(!dataNode["CertIdentifier"].isNull())
data_.certIdentifier = std::stoi(dataNode["CertIdentifier"].asString());
data_.certIdentifier = dataNode["CertIdentifier"].asString();
if(!dataNode["GmtCreate"].isNull())
data_.gmtCreate = dataNode["GmtCreate"].asString();
if(!dataNode["GmtModified"].isNull())

2
mse/src/model/DeleteGatewayRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewayRequest;
DeleteGatewayRequest::DeleteGatewayRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteGateway") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
DeleteGatewayRequest::~DeleteGatewayRequest() {}

2
mse/src/model/DeleteGatewayRouteRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewayRouteRequest;
DeleteGatewayRouteRequest::DeleteGatewayRouteRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayRoute") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
DeleteGatewayRouteRequest::~DeleteGatewayRouteRequest() {}

63
mse/src/model/DeleteGatewayServiceRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mse/model/DeleteGatewayServiceRequest.h>
using AlibabaCloud::Mse::Model::DeleteGatewayServiceRequest;
DeleteGatewayServiceRequest::DeleteGatewayServiceRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayService") {
setMethod(HttpRequest::Method::Post);
}
DeleteGatewayServiceRequest::~DeleteGatewayServiceRequest() {}
std::string DeleteGatewayServiceRequest::getGatewayUniqueId() const {
return gatewayUniqueId_;
}
void DeleteGatewayServiceRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
gatewayUniqueId_ = gatewayUniqueId;
setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
}
std::string DeleteGatewayServiceRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void DeleteGatewayServiceRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string DeleteGatewayServiceRequest::getServiceId() const {
return serviceId_;
}
void DeleteGatewayServiceRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}
long DeleteGatewayServiceRequest::getGatewayId() const {
return gatewayId_;
}
void DeleteGatewayServiceRequest::setGatewayId(long gatewayId) {
gatewayId_ = gatewayId;
setParameter(std::string("GatewayId"), std::to_string(gatewayId));
}

105
mse/src/model/DeleteGatewayServiceResult.cc Normal file
View File

@@ -0,0 +1,105 @@
/*
* 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/mse/model/DeleteGatewayServiceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
DeleteGatewayServiceResult::DeleteGatewayServiceResult() :
ServiceResult()
{}
DeleteGatewayServiceResult::DeleteGatewayServiceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteGatewayServiceResult::~DeleteGatewayServiceResult()
{}
void DeleteGatewayServiceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Id"].isNull())
data_.id = std::stol(dataNode["Id"].asString());
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["GatewayUniqueId"].isNull())
data_.gatewayUniqueId = dataNode["GatewayUniqueId"].asString();
if(!dataNode["GatewayId"].isNull())
data_.gatewayId = std::stol(dataNode["GatewayId"].asString());
if(!dataNode["SourceType"].isNull())
data_.sourceType = dataNode["SourceType"].asString();
if(!dataNode["Namespace"].isNull())
data_._namespace = dataNode["Namespace"].asString();
if(!dataNode["GroupName"].isNull())
data_.groupName = dataNode["GroupName"].asString();
if(!dataNode["SourceId"].isNull())
data_.sourceId = std::stol(dataNode["SourceId"].asString());
if(!dataNode["ServiceNameInRegistry"].isNull())
data_.serviceNameInRegistry = dataNode["ServiceNameInRegistry"].asString();
if(!dataNode["MetaInfo"].isNull())
data_.metaInfo = dataNode["MetaInfo"].asString();
if(!dataNode["GmtCreate"].isNull())
data_.gmtCreate = dataNode["GmtCreate"].asString();
if(!dataNode["GmtModified"].isNull())
data_.gmtModified = dataNode["GmtModified"].asString();
auto allIps = dataNode["Ips"]["Ips"];
for (auto value : allIps)
data_.ips.push_back(value.asString());
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string DeleteGatewayServiceResult::getMessage()const
{
return message_;
}
int DeleteGatewayServiceResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
DeleteGatewayServiceResult::Data DeleteGatewayServiceResult::getData()const
{
return data_;
}
int DeleteGatewayServiceResult::getCode()const
{
return code_;
}
bool DeleteGatewayServiceResult::getSuccess()const
{
return success_;
}

2
mse/src/model/DeleteGatewaySlbRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewaySlbRequest;
DeleteGatewaySlbRequest::DeleteGatewaySlbRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteGatewaySlb") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
DeleteGatewaySlbRequest::~DeleteGatewaySlbRequest() {}

45
mse/src/model/DeleteSeataServerRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mse/model/DeleteSeataServerRequest.h>
using AlibabaCloud::Mse::Model::DeleteSeataServerRequest;
DeleteSeataServerRequest::DeleteSeataServerRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteSeataServer") {
setMethod(HttpRequest::Method::Post);
}
DeleteSeataServerRequest::~DeleteSeataServerRequest() {}
std::string DeleteSeataServerRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void DeleteSeataServerRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
std::string DeleteSeataServerRequest::getSeataServerUniqueId() const {
return seataServerUniqueId_;
}
void DeleteSeataServerRequest::setSeataServerUniqueId(const std::string &seataServerUniqueId) {
seataServerUniqueId_ = seataServerUniqueId;
setParameter(std::string("SeataServerUniqueId"), seataServerUniqueId);
}

79
mse/src/model/DeleteSeataServerResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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/mse/model/DeleteSeataServerResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
DeleteSeataServerResult::DeleteSeataServerResult() :
ServiceResult()
{}
DeleteSeataServerResult::DeleteSeataServerResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSeataServerResult::~DeleteSeataServerResult()
{}
void DeleteSeataServerResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string DeleteSeataServerResult::getMessage()const
{
return message_;
}
int DeleteSeataServerResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string DeleteSeataServerResult::getData()const
{
return data_;
}
int DeleteSeataServerResult::getCode()const
{
return code_;
}
bool DeleteSeataServerResult::getSuccess()const
{
return success_;
}

54
mse/src/model/DeleteSecurityGroupRuleRequest.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mse/model/DeleteSecurityGroupRuleRequest.h>
using AlibabaCloud::Mse::Model::DeleteSecurityGroupRuleRequest;
DeleteSecurityGroupRuleRequest::DeleteSecurityGroupRuleRequest()
: RpcServiceRequest("mse", "2019-05-31", "DeleteSecurityGroupRule") {
setMethod(HttpRequest::Method::Post);
}
DeleteSecurityGroupRuleRequest::~DeleteSecurityGroupRuleRequest() {}
std::string DeleteSecurityGroupRuleRequest::getGatewayUniqueId() const {
return gatewayUniqueId_;
}
void DeleteSecurityGroupRuleRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
gatewayUniqueId_ = gatewayUniqueId;
setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
}
std::string DeleteSecurityGroupRuleRequest::getAcceptLanguage() const {
return acceptLanguage_;
}
void DeleteSecurityGroupRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
acceptLanguage_ = acceptLanguage;
setParameter(std::string("AcceptLanguage"), acceptLanguage);
}
long DeleteSecurityGroupRuleRequest::getId() const {
return id_;
}
void DeleteSecurityGroupRuleRequest::setId(long id) {
id_ = id;
setParameter(std::string("Id"), std::to_string(id));
}

96
mse/src/model/DeleteSecurityGroupRuleResult.cc Normal file
View File

@@ -0,0 +1,96 @@
/*
* 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/mse/model/DeleteSecurityGroupRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mse;
using namespace AlibabaCloud::Mse::Model;
DeleteSecurityGroupRuleResult::DeleteSecurityGroupRuleResult() :
ServiceResult()
{}
DeleteSecurityGroupRuleResult::DeleteSecurityGroupRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSecurityGroupRuleResult::~DeleteSecurityGroupRuleResult()
{}
void DeleteSecurityGroupRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Id"].isNull())
data_.id = std::stol(dataNode["Id"].asString());
if(!dataNode["SecurityGroupId"].isNull())
data_.securityGroupId = dataNode["SecurityGroupId"].asString();
if(!dataNode["GatewayUniqueId"].isNull())
data_.gatewayUniqueId = dataNode["GatewayUniqueId"].asString();
if(!dataNode["PortRange"].isNull())
data_.portRange = dataNode["PortRange"].asString();
if(!dataNode["IpProtocol"].isNull())
data_.ipProtocol = dataNode["IpProtocol"].asString();
if(!dataNode["GatewayId"].isNull())
data_.gatewayId = std::stol(dataNode["GatewayId"].asString());
if(!dataNode["GmtCreate"].isNull())
data_.gmtCreate = dataNode["GmtCreate"].asString();
if(!dataNode["GmtModified"].isNull())
data_.gmtModified = dataNode["GmtModified"].asString();
if(!dataNode["Description"].isNull())
data_.description = dataNode["Description"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string DeleteSecurityGroupRuleResult::getMessage()const
{
return message_;
}
int DeleteSecurityGroupRuleResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
DeleteSecurityGroupRuleResult::Data DeleteSecurityGroupRuleResult::getData()const
{
return data_;
}
int DeleteSecurityGroupRuleResult::getCode()const
{
return code_;
}
bool DeleteSecurityGroupRuleResult::getSuccess()const
{
return success_;
}

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