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

Generated 2014-08-28 for Ess.

Browse Source
This commit is contained in:
sdk-team
2025-04-25 07:04:42 +00:00
parent 1f2e0e0b42
commit 9b2557bf41
223 changed files with 19126 additions and 14475 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2062
1.36.2063

52
ess/CMakeLists.txt
View File

@@ -21,18 +21,26 @@ set(ess_public_header
include/alibabacloud/ess/EssExport.h )
set(ess_public_header_model
include/alibabacloud/ess/model/AttachAlbServerGroupsRequest.h
include/alibabacloud/ess/model/AttachAlbServerGroupsResult.h
include/alibabacloud/ess/model/AttachDBInstancesRequest.h
include/alibabacloud/ess/model/AttachDBInstancesResult.h
include/alibabacloud/ess/model/AttachInstancesRequest.h
include/alibabacloud/ess/model/AttachInstancesResult.h
include/alibabacloud/ess/model/AttachLoadBalancersRequest.h
include/alibabacloud/ess/model/AttachLoadBalancersResult.h
include/alibabacloud/ess/model/AttachServerGroupsRequest.h
include/alibabacloud/ess/model/AttachServerGroupsResult.h
include/alibabacloud/ess/model/AttachVServerGroupsRequest.h
include/alibabacloud/ess/model/AttachVServerGroupsResult.h
include/alibabacloud/ess/model/ChangeResourceGroupRequest.h
include/alibabacloud/ess/model/ChangeResourceGroupResult.h
include/alibabacloud/ess/model/CompleteLifecycleActionRequest.h
include/alibabacloud/ess/model/CompleteLifecycleActionResult.h
include/alibabacloud/ess/model/CreateAlarmRequest.h
include/alibabacloud/ess/model/CreateAlarmResult.h
include/alibabacloud/ess/model/CreateEciScalingConfigurationRequest.h
include/alibabacloud/ess/model/CreateEciScalingConfigurationResult.h
include/alibabacloud/ess/model/CreateLifecycleHookRequest.h
include/alibabacloud/ess/model/CreateLifecycleHookResult.h
include/alibabacloud/ess/model/CreateNotificationConfigurationRequest.h
@@ -49,6 +57,8 @@ set(ess_public_header_model
include/alibabacloud/ess/model/DeactivateScalingConfigurationResult.h
include/alibabacloud/ess/model/DeleteAlarmRequest.h
include/alibabacloud/ess/model/DeleteAlarmResult.h
include/alibabacloud/ess/model/DeleteEciScalingConfigurationRequest.h
include/alibabacloud/ess/model/DeleteEciScalingConfigurationResult.h
include/alibabacloud/ess/model/DeleteLifecycleHookRequest.h
include/alibabacloud/ess/model/DeleteLifecycleHookResult.h
include/alibabacloud/ess/model/DeleteNotificationConfigurationRequest.h
@@ -63,6 +73,10 @@ set(ess_public_header_model
include/alibabacloud/ess/model/DeleteScheduledTaskResult.h
include/alibabacloud/ess/model/DescribeAlarmsRequest.h
include/alibabacloud/ess/model/DescribeAlarmsResult.h
include/alibabacloud/ess/model/DescribeEciScalingConfigurationsRequest.h
include/alibabacloud/ess/model/DescribeEciScalingConfigurationsResult.h
include/alibabacloud/ess/model/DescribeElasticStrengthRequest.h
include/alibabacloud/ess/model/DescribeElasticStrengthResult.h
include/alibabacloud/ess/model/DescribeLifecycleActionsRequest.h
include/alibabacloud/ess/model/DescribeLifecycleActionsResult.h
include/alibabacloud/ess/model/DescribeLifecycleHooksRequest.h
@@ -73,6 +87,8 @@ set(ess_public_header_model
include/alibabacloud/ess/model/DescribeNotificationConfigurationsResult.h
include/alibabacloud/ess/model/DescribeNotificationTypesRequest.h
include/alibabacloud/ess/model/DescribeNotificationTypesResult.h
include/alibabacloud/ess/model/DescribePatternTypesRequest.h
include/alibabacloud/ess/model/DescribePatternTypesResult.h
include/alibabacloud/ess/model/DescribeRegionsRequest.h
include/alibabacloud/ess/model/DescribeRegionsResult.h
include/alibabacloud/ess/model/DescribeScalingActivitiesRequest.h
@@ -89,12 +105,16 @@ set(ess_public_header_model
include/alibabacloud/ess/model/DescribeScalingRulesResult.h
include/alibabacloud/ess/model/DescribeScheduledTasksRequest.h
include/alibabacloud/ess/model/DescribeScheduledTasksResult.h
include/alibabacloud/ess/model/DetachAlbServerGroupsRequest.h
include/alibabacloud/ess/model/DetachAlbServerGroupsResult.h
include/alibabacloud/ess/model/DetachDBInstancesRequest.h
include/alibabacloud/ess/model/DetachDBInstancesResult.h
include/alibabacloud/ess/model/DetachInstancesRequest.h
include/alibabacloud/ess/model/DetachInstancesResult.h
include/alibabacloud/ess/model/DetachLoadBalancersRequest.h
include/alibabacloud/ess/model/DetachLoadBalancersResult.h
include/alibabacloud/ess/model/DetachServerGroupsRequest.h
include/alibabacloud/ess/model/DetachServerGroupsResult.h
include/alibabacloud/ess/model/DetachVServerGroupsRequest.h
include/alibabacloud/ess/model/DetachVServerGroupsResult.h
include/alibabacloud/ess/model/DisableAlarmRequest.h
@@ -119,6 +139,10 @@ set(ess_public_header_model
include/alibabacloud/ess/model/ListTagValuesResult.h
include/alibabacloud/ess/model/ModifyAlarmRequest.h
include/alibabacloud/ess/model/ModifyAlarmResult.h
include/alibabacloud/ess/model/ModifyEciScalingConfigurationRequest.h
include/alibabacloud/ess/model/ModifyEciScalingConfigurationResult.h
include/alibabacloud/ess/model/ModifyInstanceAttributeRequest.h
include/alibabacloud/ess/model/ModifyInstanceAttributeResult.h
include/alibabacloud/ess/model/ModifyLifecycleHookRequest.h
include/alibabacloud/ess/model/ModifyLifecycleHookResult.h
include/alibabacloud/ess/model/ModifyNotificationConfigurationRequest.h
@@ -139,6 +163,8 @@ set(ess_public_header_model
include/alibabacloud/ess/model/RemoveInstancesResult.h
include/alibabacloud/ess/model/ResumeProcessesRequest.h
include/alibabacloud/ess/model/ResumeProcessesResult.h
include/alibabacloud/ess/model/ScaleWithAdjustmentRequest.h
include/alibabacloud/ess/model/ScaleWithAdjustmentResult.h
include/alibabacloud/ess/model/SetGroupDeletionProtectionRequest.h
include/alibabacloud/ess/model/SetGroupDeletionProtectionResult.h
include/alibabacloud/ess/model/SetInstanceHealthRequest.h
@@ -158,18 +184,26 @@ set(ess_public_header_model
set(ess_src
src/EssClient.cc
src/model/AttachAlbServerGroupsRequest.cc
src/model/AttachAlbServerGroupsResult.cc
src/model/AttachDBInstancesRequest.cc
src/model/AttachDBInstancesResult.cc
src/model/AttachInstancesRequest.cc
src/model/AttachInstancesResult.cc
src/model/AttachLoadBalancersRequest.cc
src/model/AttachLoadBalancersResult.cc
src/model/AttachServerGroupsRequest.cc
src/model/AttachServerGroupsResult.cc
src/model/AttachVServerGroupsRequest.cc
src/model/AttachVServerGroupsResult.cc
src/model/ChangeResourceGroupRequest.cc
src/model/ChangeResourceGroupResult.cc
src/model/CompleteLifecycleActionRequest.cc
src/model/CompleteLifecycleActionResult.cc
src/model/CreateAlarmRequest.cc
src/model/CreateAlarmResult.cc
src/model/CreateEciScalingConfigurationRequest.cc
src/model/CreateEciScalingConfigurationResult.cc
src/model/CreateLifecycleHookRequest.cc
src/model/CreateLifecycleHookResult.cc
src/model/CreateNotificationConfigurationRequest.cc
@@ -186,6 +220,8 @@ set(ess_src
src/model/DeactivateScalingConfigurationResult.cc
src/model/DeleteAlarmRequest.cc
src/model/DeleteAlarmResult.cc
src/model/DeleteEciScalingConfigurationRequest.cc
src/model/DeleteEciScalingConfigurationResult.cc
src/model/DeleteLifecycleHookRequest.cc
src/model/DeleteLifecycleHookResult.cc
src/model/DeleteNotificationConfigurationRequest.cc
@@ -200,6 +236,10 @@ set(ess_src
src/model/DeleteScheduledTaskResult.cc
src/model/DescribeAlarmsRequest.cc
src/model/DescribeAlarmsResult.cc
src/model/DescribeEciScalingConfigurationsRequest.cc
src/model/DescribeEciScalingConfigurationsResult.cc
src/model/DescribeElasticStrengthRequest.cc
src/model/DescribeElasticStrengthResult.cc
src/model/DescribeLifecycleActionsRequest.cc
src/model/DescribeLifecycleActionsResult.cc
src/model/DescribeLifecycleHooksRequest.cc
@@ -210,6 +250,8 @@ set(ess_src
src/model/DescribeNotificationConfigurationsResult.cc
src/model/DescribeNotificationTypesRequest.cc
src/model/DescribeNotificationTypesResult.cc
src/model/DescribePatternTypesRequest.cc
src/model/DescribePatternTypesResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DescribeScalingActivitiesRequest.cc
@@ -226,12 +268,16 @@ set(ess_src
src/model/DescribeScalingRulesResult.cc
src/model/DescribeScheduledTasksRequest.cc
src/model/DescribeScheduledTasksResult.cc
src/model/DetachAlbServerGroupsRequest.cc
src/model/DetachAlbServerGroupsResult.cc
src/model/DetachDBInstancesRequest.cc
src/model/DetachDBInstancesResult.cc
src/model/DetachInstancesRequest.cc
src/model/DetachInstancesResult.cc
src/model/DetachLoadBalancersRequest.cc
src/model/DetachLoadBalancersResult.cc
src/model/DetachServerGroupsRequest.cc
src/model/DetachServerGroupsResult.cc
src/model/DetachVServerGroupsRequest.cc
src/model/DetachVServerGroupsResult.cc
src/model/DisableAlarmRequest.cc
@@ -256,6 +302,10 @@ set(ess_src
src/model/ListTagValuesResult.cc
src/model/ModifyAlarmRequest.cc
src/model/ModifyAlarmResult.cc
src/model/ModifyEciScalingConfigurationRequest.cc
src/model/ModifyEciScalingConfigurationResult.cc
src/model/ModifyInstanceAttributeRequest.cc
src/model/ModifyInstanceAttributeResult.cc
src/model/ModifyLifecycleHookRequest.cc
src/model/ModifyLifecycleHookResult.cc
src/model/ModifyNotificationConfigurationRequest.cc
@@ -276,6 +326,8 @@ set(ess_src
src/model/RemoveInstancesResult.cc
src/model/ResumeProcessesRequest.cc
src/model/ResumeProcessesResult.cc
src/model/ScaleWithAdjustmentRequest.cc
src/model/ScaleWithAdjustmentResult.cc
src/model/SetGroupDeletionProtectionRequest.cc
src/model/SetGroupDeletionProtectionResult.cc
src/model/SetInstanceHealthRequest.cc

104
ess/include/alibabacloud/ess/EssClient.h
View File

@@ -22,18 +22,26 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "EssExport.h"
#include "model/AttachAlbServerGroupsRequest.h"
#include "model/AttachAlbServerGroupsResult.h"
#include "model/AttachDBInstancesRequest.h"
#include "model/AttachDBInstancesResult.h"
#include "model/AttachInstancesRequest.h"
#include "model/AttachInstancesResult.h"
#include "model/AttachLoadBalancersRequest.h"
#include "model/AttachLoadBalancersResult.h"
#include "model/AttachServerGroupsRequest.h"
#include "model/AttachServerGroupsResult.h"
#include "model/AttachVServerGroupsRequest.h"
#include "model/AttachVServerGroupsResult.h"
#include "model/ChangeResourceGroupRequest.h"
#include "model/ChangeResourceGroupResult.h"
#include "model/CompleteLifecycleActionRequest.h"
#include "model/CompleteLifecycleActionResult.h"
#include "model/CreateAlarmRequest.h"
#include "model/CreateAlarmResult.h"
#include "model/CreateEciScalingConfigurationRequest.h"
#include "model/CreateEciScalingConfigurationResult.h"
#include "model/CreateLifecycleHookRequest.h"
#include "model/CreateLifecycleHookResult.h"
#include "model/CreateNotificationConfigurationRequest.h"
@@ -50,6 +58,8 @@
#include "model/DeactivateScalingConfigurationResult.h"
#include "model/DeleteAlarmRequest.h"
#include "model/DeleteAlarmResult.h"
#include "model/DeleteEciScalingConfigurationRequest.h"
#include "model/DeleteEciScalingConfigurationResult.h"
#include "model/DeleteLifecycleHookRequest.h"
#include "model/DeleteLifecycleHookResult.h"
#include "model/DeleteNotificationConfigurationRequest.h"
@@ -64,6 +74,10 @@
#include "model/DeleteScheduledTaskResult.h"
#include "model/DescribeAlarmsRequest.h"
#include "model/DescribeAlarmsResult.h"
#include "model/DescribeEciScalingConfigurationsRequest.h"
#include "model/DescribeEciScalingConfigurationsResult.h"
#include "model/DescribeElasticStrengthRequest.h"
#include "model/DescribeElasticStrengthResult.h"
#include "model/DescribeLifecycleActionsRequest.h"
#include "model/DescribeLifecycleActionsResult.h"
#include "model/DescribeLifecycleHooksRequest.h"
@@ -74,6 +88,8 @@
#include "model/DescribeNotificationConfigurationsResult.h"
#include "model/DescribeNotificationTypesRequest.h"
#include "model/DescribeNotificationTypesResult.h"
#include "model/DescribePatternTypesRequest.h"
#include "model/DescribePatternTypesResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeScalingActivitiesRequest.h"
@@ -90,12 +106,16 @@
#include "model/DescribeScalingRulesResult.h"
#include "model/DescribeScheduledTasksRequest.h"
#include "model/DescribeScheduledTasksResult.h"
#include "model/DetachAlbServerGroupsRequest.h"
#include "model/DetachAlbServerGroupsResult.h"
#include "model/DetachDBInstancesRequest.h"
#include "model/DetachDBInstancesResult.h"
#include "model/DetachInstancesRequest.h"
#include "model/DetachInstancesResult.h"
#include "model/DetachLoadBalancersRequest.h"
#include "model/DetachLoadBalancersResult.h"
#include "model/DetachServerGroupsRequest.h"
#include "model/DetachServerGroupsResult.h"
#include "model/DetachVServerGroupsRequest.h"
#include "model/DetachVServerGroupsResult.h"
#include "model/DisableAlarmRequest.h"
@@ -120,6 +140,10 @@
#include "model/ListTagValuesResult.h"
#include "model/ModifyAlarmRequest.h"
#include "model/ModifyAlarmResult.h"
#include "model/ModifyEciScalingConfigurationRequest.h"
#include "model/ModifyEciScalingConfigurationResult.h"
#include "model/ModifyInstanceAttributeRequest.h"
#include "model/ModifyInstanceAttributeResult.h"
#include "model/ModifyLifecycleHookRequest.h"
#include "model/ModifyLifecycleHookResult.h"
#include "model/ModifyNotificationConfigurationRequest.h"
@@ -140,6 +164,8 @@
#include "model/RemoveInstancesResult.h"
#include "model/ResumeProcessesRequest.h"
#include "model/ResumeProcessesResult.h"
#include "model/ScaleWithAdjustmentRequest.h"
#include "model/ScaleWithAdjustmentResult.h"
#include "model/SetGroupDeletionProtectionRequest.h"
#include "model/SetGroupDeletionProtectionResult.h"
#include "model/SetInstanceHealthRequest.h"
@@ -165,6 +191,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_ESS_EXPORT EssClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AttachAlbServerGroupsResult> AttachAlbServerGroupsOutcome;
typedef std::future<AttachAlbServerGroupsOutcome> AttachAlbServerGroupsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::AttachAlbServerGroupsRequest&, const AttachAlbServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachAlbServerGroupsAsyncHandler;
typedef Outcome<Error, Model::AttachDBInstancesResult> AttachDBInstancesOutcome;
typedef std::future<AttachDBInstancesOutcome> AttachDBInstancesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::AttachDBInstancesRequest&, const AttachDBInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachDBInstancesAsyncHandler;
@@ -174,15 +203,24 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AttachLoadBalancersResult> AttachLoadBalancersOutcome;
typedef std::future<AttachLoadBalancersOutcome> AttachLoadBalancersOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::AttachLoadBalancersRequest&, const AttachLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachLoadBalancersAsyncHandler;
typedef Outcome<Error, Model::AttachServerGroupsResult> AttachServerGroupsOutcome;
typedef std::future<AttachServerGroupsOutcome> AttachServerGroupsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::AttachServerGroupsRequest&, const AttachServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachServerGroupsAsyncHandler;
typedef Outcome<Error, Model::AttachVServerGroupsResult> AttachVServerGroupsOutcome;
typedef std::future<AttachVServerGroupsOutcome> AttachVServerGroupsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::AttachVServerGroupsRequest&, const AttachVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachVServerGroupsAsyncHandler;
typedef Outcome<Error, Model::ChangeResourceGroupResult> ChangeResourceGroupOutcome;
typedef std::future<ChangeResourceGroupOutcome> ChangeResourceGroupOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ChangeResourceGroupRequest&, const ChangeResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeResourceGroupAsyncHandler;
typedef Outcome<Error, Model::CompleteLifecycleActionResult> CompleteLifecycleActionOutcome;
typedef std::future<CompleteLifecycleActionOutcome> CompleteLifecycleActionOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::CompleteLifecycleActionRequest&, const CompleteLifecycleActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompleteLifecycleActionAsyncHandler;
typedef Outcome<Error, Model::CreateAlarmResult> CreateAlarmOutcome;
typedef std::future<CreateAlarmOutcome> CreateAlarmOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::CreateAlarmRequest&, const CreateAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlarmAsyncHandler;
typedef Outcome<Error, Model::CreateEciScalingConfigurationResult> CreateEciScalingConfigurationOutcome;
typedef std::future<CreateEciScalingConfigurationOutcome> CreateEciScalingConfigurationOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::CreateEciScalingConfigurationRequest&, const CreateEciScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEciScalingConfigurationAsyncHandler;
typedef Outcome<Error, Model::CreateLifecycleHookResult> CreateLifecycleHookOutcome;
typedef std::future<CreateLifecycleHookOutcome> CreateLifecycleHookOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::CreateLifecycleHookRequest&, const CreateLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLifecycleHookAsyncHandler;
@@ -207,6 +245,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteAlarmResult> DeleteAlarmOutcome;
typedef std::future<DeleteAlarmOutcome> DeleteAlarmOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DeleteAlarmRequest&, const DeleteAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlarmAsyncHandler;
typedef Outcome<Error, Model::DeleteEciScalingConfigurationResult> DeleteEciScalingConfigurationOutcome;
typedef std::future<DeleteEciScalingConfigurationOutcome> DeleteEciScalingConfigurationOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DeleteEciScalingConfigurationRequest&, const DeleteEciScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEciScalingConfigurationAsyncHandler;
typedef Outcome<Error, Model::DeleteLifecycleHookResult> DeleteLifecycleHookOutcome;
typedef std::future<DeleteLifecycleHookOutcome> DeleteLifecycleHookOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DeleteLifecycleHookRequest&, const DeleteLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLifecycleHookAsyncHandler;
@@ -228,6 +269,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeAlarmsResult> DescribeAlarmsOutcome;
typedef std::future<DescribeAlarmsOutcome> DescribeAlarmsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeAlarmsRequest&, const DescribeAlarmsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlarmsAsyncHandler;
typedef Outcome<Error, Model::DescribeEciScalingConfigurationsResult> DescribeEciScalingConfigurationsOutcome;
typedef std::future<DescribeEciScalingConfigurationsOutcome> DescribeEciScalingConfigurationsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeEciScalingConfigurationsRequest&, const DescribeEciScalingConfigurationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEciScalingConfigurationsAsyncHandler;
typedef Outcome<Error, Model::DescribeElasticStrengthResult> DescribeElasticStrengthOutcome;
typedef std::future<DescribeElasticStrengthOutcome> DescribeElasticStrengthOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeElasticStrengthRequest&, const DescribeElasticStrengthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeElasticStrengthAsyncHandler;
typedef Outcome<Error, Model::DescribeLifecycleActionsResult> DescribeLifecycleActionsOutcome;
typedef std::future<DescribeLifecycleActionsOutcome> DescribeLifecycleActionsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeLifecycleActionsRequest&, const DescribeLifecycleActionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLifecycleActionsAsyncHandler;
@@ -243,6 +290,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeNotificationTypesResult> DescribeNotificationTypesOutcome;
typedef std::future<DescribeNotificationTypesOutcome> DescribeNotificationTypesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeNotificationTypesRequest&, const DescribeNotificationTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNotificationTypesAsyncHandler;
typedef Outcome<Error, Model::DescribePatternTypesResult> DescribePatternTypesOutcome;
typedef std::future<DescribePatternTypesOutcome> DescribePatternTypesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribePatternTypesRequest&, const DescribePatternTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePatternTypesAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
@@ -267,6 +317,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeScheduledTasksResult> DescribeScheduledTasksOutcome;
typedef std::future<DescribeScheduledTasksOutcome> DescribeScheduledTasksOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeScheduledTasksRequest&, const DescribeScheduledTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScheduledTasksAsyncHandler;
typedef Outcome<Error, Model::DetachAlbServerGroupsResult> DetachAlbServerGroupsOutcome;
typedef std::future<DetachAlbServerGroupsOutcome> DetachAlbServerGroupsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DetachAlbServerGroupsRequest&, const DetachAlbServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachAlbServerGroupsAsyncHandler;
typedef Outcome<Error, Model::DetachDBInstancesResult> DetachDBInstancesOutcome;
typedef std::future<DetachDBInstancesOutcome> DetachDBInstancesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DetachDBInstancesRequest&, const DetachDBInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachDBInstancesAsyncHandler;
@@ -276,6 +329,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DetachLoadBalancersResult> DetachLoadBalancersOutcome;
typedef std::future<DetachLoadBalancersOutcome> DetachLoadBalancersOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DetachLoadBalancersRequest&, const DetachLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachLoadBalancersAsyncHandler;
typedef Outcome<Error, Model::DetachServerGroupsResult> DetachServerGroupsOutcome;
typedef std::future<DetachServerGroupsOutcome> DetachServerGroupsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DetachServerGroupsRequest&, const DetachServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachServerGroupsAsyncHandler;
typedef Outcome<Error, Model::DetachVServerGroupsResult> DetachVServerGroupsOutcome;
typedef std::future<DetachVServerGroupsOutcome> DetachVServerGroupsOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DetachVServerGroupsRequest&, const DetachVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachVServerGroupsAsyncHandler;
@@ -312,6 +368,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ModifyAlarmResult> ModifyAlarmOutcome;
typedef std::future<ModifyAlarmOutcome> ModifyAlarmOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ModifyAlarmRequest&, const ModifyAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlarmAsyncHandler;
typedef Outcome<Error, Model::ModifyEciScalingConfigurationResult> ModifyEciScalingConfigurationOutcome;
typedef std::future<ModifyEciScalingConfigurationOutcome> ModifyEciScalingConfigurationOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ModifyEciScalingConfigurationRequest&, const ModifyEciScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyEciScalingConfigurationAsyncHandler;
typedef Outcome<Error, Model::ModifyInstanceAttributeResult> ModifyInstanceAttributeOutcome;
typedef std::future<ModifyInstanceAttributeOutcome> ModifyInstanceAttributeOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ModifyInstanceAttributeRequest&, const ModifyInstanceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceAttributeAsyncHandler;
typedef Outcome<Error, Model::ModifyLifecycleHookResult> ModifyLifecycleHookOutcome;
typedef std::future<ModifyLifecycleHookOutcome> ModifyLifecycleHookOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ModifyLifecycleHookRequest&, const ModifyLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLifecycleHookAsyncHandler;
@@ -342,6 +404,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ResumeProcessesResult> ResumeProcessesOutcome;
typedef std::future<ResumeProcessesOutcome> ResumeProcessesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ResumeProcessesRequest&, const ResumeProcessesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumeProcessesAsyncHandler;
typedef Outcome<Error, Model::ScaleWithAdjustmentResult> ScaleWithAdjustmentOutcome;
typedef std::future<ScaleWithAdjustmentOutcome> ScaleWithAdjustmentOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ScaleWithAdjustmentRequest&, const ScaleWithAdjustmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScaleWithAdjustmentAsyncHandler;
typedef Outcome<Error, Model::SetGroupDeletionProtectionResult> SetGroupDeletionProtectionOutcome;
typedef std::future<SetGroupDeletionProtectionOutcome> SetGroupDeletionProtectionOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::SetGroupDeletionProtectionRequest&, const SetGroupDeletionProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGroupDeletionProtectionAsyncHandler;
@@ -371,6 +436,9 @@ namespace AlibabaCloud
EssClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
EssClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~EssClient();
AttachAlbServerGroupsOutcome attachAlbServerGroups(const Model::AttachAlbServerGroupsRequest &request)const;
void attachAlbServerGroupsAsync(const Model::AttachAlbServerGroupsRequest& request, const AttachAlbServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachAlbServerGroupsOutcomeCallable attachAlbServerGroupsCallable(const Model::AttachAlbServerGroupsRequest& request) const;
AttachDBInstancesOutcome attachDBInstances(const Model::AttachDBInstancesRequest &request)const;
void attachDBInstancesAsync(const Model::AttachDBInstancesRequest& request, const AttachDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachDBInstancesOutcomeCallable attachDBInstancesCallable(const Model::AttachDBInstancesRequest& request) const;
@@ -380,15 +448,24 @@ namespace AlibabaCloud
AttachLoadBalancersOutcome attachLoadBalancers(const Model::AttachLoadBalancersRequest &request)const;
void attachLoadBalancersAsync(const Model::AttachLoadBalancersRequest& request, const AttachLoadBalancersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachLoadBalancersOutcomeCallable attachLoadBalancersCallable(const Model::AttachLoadBalancersRequest& request) const;
AttachServerGroupsOutcome attachServerGroups(const Model::AttachServerGroupsRequest &request)const;
void attachServerGroupsAsync(const Model::AttachServerGroupsRequest& request, const AttachServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachServerGroupsOutcomeCallable attachServerGroupsCallable(const Model::AttachServerGroupsRequest& request) const;
AttachVServerGroupsOutcome attachVServerGroups(const Model::AttachVServerGroupsRequest &request)const;
void attachVServerGroupsAsync(const Model::AttachVServerGroupsRequest& request, const AttachVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachVServerGroupsOutcomeCallable attachVServerGroupsCallable(const Model::AttachVServerGroupsRequest& request) const;
ChangeResourceGroupOutcome changeResourceGroup(const Model::ChangeResourceGroupRequest &request)const;
void changeResourceGroupAsync(const Model::ChangeResourceGroupRequest& request, const ChangeResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeResourceGroupOutcomeCallable changeResourceGroupCallable(const Model::ChangeResourceGroupRequest& request) const;
CompleteLifecycleActionOutcome completeLifecycleAction(const Model::CompleteLifecycleActionRequest &request)const;
void completeLifecycleActionAsync(const Model::CompleteLifecycleActionRequest& request, const CompleteLifecycleActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CompleteLifecycleActionOutcomeCallable completeLifecycleActionCallable(const Model::CompleteLifecycleActionRequest& request) const;
CreateAlarmOutcome createAlarm(const Model::CreateAlarmRequest &request)const;
void createAlarmAsync(const Model::CreateAlarmRequest& request, const CreateAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAlarmOutcomeCallable createAlarmCallable(const Model::CreateAlarmRequest& request) const;
CreateEciScalingConfigurationOutcome createEciScalingConfiguration(const Model::CreateEciScalingConfigurationRequest &request)const;
void createEciScalingConfigurationAsync(const Model::CreateEciScalingConfigurationRequest& request, const CreateEciScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateEciScalingConfigurationOutcomeCallable createEciScalingConfigurationCallable(const Model::CreateEciScalingConfigurationRequest& request) const;
CreateLifecycleHookOutcome createLifecycleHook(const Model::CreateLifecycleHookRequest &request)const;
void createLifecycleHookAsync(const Model::CreateLifecycleHookRequest& request, const CreateLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLifecycleHookOutcomeCallable createLifecycleHookCallable(const Model::CreateLifecycleHookRequest& request) const;
@@ -413,6 +490,9 @@ namespace AlibabaCloud
DeleteAlarmOutcome deleteAlarm(const Model::DeleteAlarmRequest &request)const;
void deleteAlarmAsync(const Model::DeleteAlarmRequest& request, const DeleteAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAlarmOutcomeCallable deleteAlarmCallable(const Model::DeleteAlarmRequest& request) const;
DeleteEciScalingConfigurationOutcome deleteEciScalingConfiguration(const Model::DeleteEciScalingConfigurationRequest &request)const;
void deleteEciScalingConfigurationAsync(const Model::DeleteEciScalingConfigurationRequest& request, const DeleteEciScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteEciScalingConfigurationOutcomeCallable deleteEciScalingConfigurationCallable(const Model::DeleteEciScalingConfigurationRequest& request) const;
DeleteLifecycleHookOutcome deleteLifecycleHook(const Model::DeleteLifecycleHookRequest &request)const;
void deleteLifecycleHookAsync(const Model::DeleteLifecycleHookRequest& request, const DeleteLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLifecycleHookOutcomeCallable deleteLifecycleHookCallable(const Model::DeleteLifecycleHookRequest& request) const;
@@ -434,6 +514,12 @@ namespace AlibabaCloud
DescribeAlarmsOutcome describeAlarms(const Model::DescribeAlarmsRequest &request)const;
void describeAlarmsAsync(const Model::DescribeAlarmsRequest& request, const DescribeAlarmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAlarmsOutcomeCallable describeAlarmsCallable(const Model::DescribeAlarmsRequest& request) const;
DescribeEciScalingConfigurationsOutcome describeEciScalingConfigurations(const Model::DescribeEciScalingConfigurationsRequest &request)const;
void describeEciScalingConfigurationsAsync(const Model::DescribeEciScalingConfigurationsRequest& request, const DescribeEciScalingConfigurationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeEciScalingConfigurationsOutcomeCallable describeEciScalingConfigurationsCallable(const Model::DescribeEciScalingConfigurationsRequest& request) const;
DescribeElasticStrengthOutcome describeElasticStrength(const Model::DescribeElasticStrengthRequest &request)const;
void describeElasticStrengthAsync(const Model::DescribeElasticStrengthRequest& request, const DescribeElasticStrengthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeElasticStrengthOutcomeCallable describeElasticStrengthCallable(const Model::DescribeElasticStrengthRequest& request) const;
DescribeLifecycleActionsOutcome describeLifecycleActions(const Model::DescribeLifecycleActionsRequest &request)const;
void describeLifecycleActionsAsync(const Model::DescribeLifecycleActionsRequest& request, const DescribeLifecycleActionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLifecycleActionsOutcomeCallable describeLifecycleActionsCallable(const Model::DescribeLifecycleActionsRequest& request) const;
@@ -449,6 +535,9 @@ namespace AlibabaCloud
DescribeNotificationTypesOutcome describeNotificationTypes(const Model::DescribeNotificationTypesRequest &request)const;
void describeNotificationTypesAsync(const Model::DescribeNotificationTypesRequest& request, const DescribeNotificationTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeNotificationTypesOutcomeCallable describeNotificationTypesCallable(const Model::DescribeNotificationTypesRequest& request) const;
DescribePatternTypesOutcome describePatternTypes(const Model::DescribePatternTypesRequest &request)const;
void describePatternTypesAsync(const Model::DescribePatternTypesRequest& request, const DescribePatternTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePatternTypesOutcomeCallable describePatternTypesCallable(const Model::DescribePatternTypesRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
@@ -473,6 +562,9 @@ namespace AlibabaCloud
DescribeScheduledTasksOutcome describeScheduledTasks(const Model::DescribeScheduledTasksRequest &request)const;
void describeScheduledTasksAsync(const Model::DescribeScheduledTasksRequest& request, const DescribeScheduledTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScheduledTasksOutcomeCallable describeScheduledTasksCallable(const Model::DescribeScheduledTasksRequest& request) const;
DetachAlbServerGroupsOutcome detachAlbServerGroups(const Model::DetachAlbServerGroupsRequest &request)const;
void detachAlbServerGroupsAsync(const Model::DetachAlbServerGroupsRequest& request, const DetachAlbServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachAlbServerGroupsOutcomeCallable detachAlbServerGroupsCallable(const Model::DetachAlbServerGroupsRequest& request) const;
DetachDBInstancesOutcome detachDBInstances(const Model::DetachDBInstancesRequest &request)const;
void detachDBInstancesAsync(const Model::DetachDBInstancesRequest& request, const DetachDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachDBInstancesOutcomeCallable detachDBInstancesCallable(const Model::DetachDBInstancesRequest& request) const;
@@ -482,6 +574,9 @@ namespace AlibabaCloud
DetachLoadBalancersOutcome detachLoadBalancers(const Model::DetachLoadBalancersRequest &request)const;
void detachLoadBalancersAsync(const Model::DetachLoadBalancersRequest& request, const DetachLoadBalancersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachLoadBalancersOutcomeCallable detachLoadBalancersCallable(const Model::DetachLoadBalancersRequest& request) const;
DetachServerGroupsOutcome detachServerGroups(const Model::DetachServerGroupsRequest &request)const;
void detachServerGroupsAsync(const Model::DetachServerGroupsRequest& request, const DetachServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachServerGroupsOutcomeCallable detachServerGroupsCallable(const Model::DetachServerGroupsRequest& request) const;
DetachVServerGroupsOutcome detachVServerGroups(const Model::DetachVServerGroupsRequest &request)const;
void detachVServerGroupsAsync(const Model::DetachVServerGroupsRequest& request, const DetachVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachVServerGroupsOutcomeCallable detachVServerGroupsCallable(const Model::DetachVServerGroupsRequest& request) const;
@@ -518,6 +613,12 @@ namespace AlibabaCloud
ModifyAlarmOutcome modifyAlarm(const Model::ModifyAlarmRequest &request)const;
void modifyAlarmAsync(const Model::ModifyAlarmRequest& request, const ModifyAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAlarmOutcomeCallable modifyAlarmCallable(const Model::ModifyAlarmRequest& request) const;
ModifyEciScalingConfigurationOutcome modifyEciScalingConfiguration(const Model::ModifyEciScalingConfigurationRequest &request)const;
void modifyEciScalingConfigurationAsync(const Model::ModifyEciScalingConfigurationRequest& request, const ModifyEciScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyEciScalingConfigurationOutcomeCallable modifyEciScalingConfigurationCallable(const Model::ModifyEciScalingConfigurationRequest& request) const;
ModifyInstanceAttributeOutcome modifyInstanceAttribute(const Model::ModifyInstanceAttributeRequest &request)const;
void modifyInstanceAttributeAsync(const Model::ModifyInstanceAttributeRequest& request, const ModifyInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyInstanceAttributeOutcomeCallable modifyInstanceAttributeCallable(const Model::ModifyInstanceAttributeRequest& request) const;
ModifyLifecycleHookOutcome modifyLifecycleHook(const Model::ModifyLifecycleHookRequest &request)const;
void modifyLifecycleHookAsync(const Model::ModifyLifecycleHookRequest& request, const ModifyLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLifecycleHookOutcomeCallable modifyLifecycleHookCallable(const Model::ModifyLifecycleHookRequest& request) const;
@@ -548,6 +649,9 @@ namespace AlibabaCloud
ResumeProcessesOutcome resumeProcesses(const Model::ResumeProcessesRequest &request)const;
void resumeProcessesAsync(const Model::ResumeProcessesRequest& request, const ResumeProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResumeProcessesOutcomeCallable resumeProcessesCallable(const Model::ResumeProcessesRequest& request) const;
ScaleWithAdjustmentOutcome scaleWithAdjustment(const Model::ScaleWithAdjustmentRequest &request)const;
void scaleWithAdjustmentAsync(const Model::ScaleWithAdjustmentRequest& request, const ScaleWithAdjustmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ScaleWithAdjustmentOutcomeCallable scaleWithAdjustmentCallable(const Model::ScaleWithAdjustmentRequest& request) const;
SetGroupDeletionProtectionOutcome setGroupDeletionProtection(const Model::SetGroupDeletionProtectionRequest &request)const;
void setGroupDeletionProtectionAsync(const Model::SetGroupDeletionProtectionRequest& request, const SetGroupDeletionProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetGroupDeletionProtectionOutcomeCallable setGroupDeletionProtectionCallable(const Model::SetGroupDeletionProtectionRequest& request) const;

68
ess/include/alibabacloud/ess/model/AttachAlbServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_ESS_MODEL_ATTACHALBSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHALBSERVERGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT AttachAlbServerGroupsRequest : public RpcServiceRequest {
public:
struct AlbServerGroup {
std::string albServerGroupId;
int port;
int weight;
};
AttachAlbServerGroupsRequest();
~AttachAlbServerGroupsRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
bool getForceAttach() const;
void setForceAttach(bool forceAttach);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<AlbServerGroup> getAlbServerGroup() const;
void setAlbServerGroup(const std::vector<AlbServerGroup> &albServerGroup);
private:
std::string clientToken_;
std::string scalingGroupId_;
bool forceAttach_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::vector<AlbServerGroup> albServerGroup_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHALBSERVERGROUPSREQUEST_H_

51
ess/include/alibabacloud/ess/model/AttachAlbServerGroupsResult.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_ESS_MODEL_ATTACHALBSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHALBSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT AttachAlbServerGroupsResult : public ServiceResult
{
public:
AttachAlbServerGroupsResult();
explicit AttachAlbServerGroupsResult(const std::string &payload);
~AttachAlbServerGroupsResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHALBSERVERGROUPSRESULT_H_

35
ess/include/alibabacloud/ess/model/AttachDBInstancesRequest.h
View File

@@ -17,32 +17,33 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ATTACHDBINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHDBINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT AttachDBInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT AttachDBInstancesRequest : public RpcServiceRequest {
public:
AttachDBInstancesRequest();
~AttachDBInstancesRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
bool getForceAttach() const;
void setForceAttach(bool forceAttach);
std::string getType() const;
void setType(const std::string &type);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getAttachMode() const;
void setAttachMode(const std::string &attachMode);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::vector<std::string> getDBInstance() const;
@@ -54,13 +55,15 @@ namespace AlibabaCloud
std::string clientToken_;
std::string scalingGroupId_;
bool forceAttach_;
std::string type_;
std::string accessKeyId_;
std::string regionId_;
std::string attachMode_;
std::string resourceOwnerAccount_;
std::vector<std::string> dBInstance_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHDBINSTANCESREQUEST_H_

170
ess/include/alibabacloud/ess/model/AttachInstancesRequest.h
View File

@@ -17,170 +17,62 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ATTACHINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT AttachInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT AttachInstancesRequest : public RpcServiceRequest {
public:
AttachInstancesRequest();
~AttachInstancesRequest();
int getLoadBalancerWeight6()const;
void setLoadBalancerWeight6(int loadBalancerWeight6);
int getLoadBalancerWeight11()const;
void setLoadBalancerWeight11(int loadBalancerWeight11);
int getLoadBalancerWeight7()const;
void setLoadBalancerWeight7(int loadBalancerWeight7);
int getLoadBalancerWeight12()const;
void setLoadBalancerWeight12(int loadBalancerWeight12);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getLoadBalancerWeight8()const;
void setLoadBalancerWeight8(int loadBalancerWeight8);
int getLoadBalancerWeight9()const;
void setLoadBalancerWeight9(int loadBalancerWeight9);
int getLoadBalancerWeight10()const;
void setLoadBalancerWeight10(int loadBalancerWeight10);
int getLoadBalancerWeight2()const;
void setLoadBalancerWeight2(int loadBalancerWeight2);
int getLoadBalancerWeight15()const;
void setLoadBalancerWeight15(int loadBalancerWeight15);
int getLoadBalancerWeight3()const;
void setLoadBalancerWeight3(int loadBalancerWeight3);
int getLoadBalancerWeight16()const;
void setLoadBalancerWeight16(int loadBalancerWeight16);
int getLoadBalancerWeight4()const;
void setLoadBalancerWeight4(int loadBalancerWeight4);
int getLoadBalancerWeight13()const;
void setLoadBalancerWeight13(int loadBalancerWeight13);
int getLoadBalancerWeight5()const;
void setLoadBalancerWeight5(int loadBalancerWeight5);
int getLoadBalancerWeight14()const;
void setLoadBalancerWeight14(int loadBalancerWeight14);
int getLoadBalancerWeight1()const;
void setLoadBalancerWeight1(int loadBalancerWeight1);
std::string getInstanceId1()const;
void setInstanceId1(const std::string& instanceId1);
int getLoadBalancerWeight20()const;
void setLoadBalancerWeight20(int loadBalancerWeight20);
std::string getInstanceId3()const;
void setInstanceId3(const std::string& instanceId3);
std::string getInstanceId2()const;
void setInstanceId2(const std::string& instanceId2);
std::string getInstanceId5()const;
void setInstanceId5(const std::string& instanceId5);
std::string getInstanceId4()const;
void setInstanceId4(const std::string& instanceId4);
std::string getInstanceId7()const;
void setInstanceId7(const std::string& instanceId7);
std::string getInstanceId6()const;
void setInstanceId6(const std::string& instanceId6);
std::string getInstanceId9()const;
void setInstanceId9(const std::string& instanceId9);
std::string getInstanceId8()const;
void setInstanceId8(const std::string& instanceId8);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getLoadBalancerWeight19()const;
void setLoadBalancerWeight19(int loadBalancerWeight19);
int getLoadBalancerWeight17()const;
void setLoadBalancerWeight17(int loadBalancerWeight17);
int getLoadBalancerWeight18()const;
void setLoadBalancerWeight18(int loadBalancerWeight18);
std::string getInstanceId10()const;
void setInstanceId10(const std::string& instanceId10);
std::string getInstanceId12()const;
void setInstanceId12(const std::string& instanceId12);
std::string getInstanceId11()const;
void setInstanceId11(const std::string& instanceId11);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getInstanceId20()const;
void setInstanceId20(const std::string& instanceId20);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
bool getIgnoreInvalidInstance() const;
void setIgnoreInvalidInstance(bool ignoreInvalidInstance);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getEntrusted() const;
void setEntrusted(bool entrusted);
std::string getInstanceId18()const;
void setInstanceId18(const std::string& instanceId18);
std::string getInstanceId17()const;
void setInstanceId17(const std::string& instanceId17);
std::string getInstanceId19()const;
void setInstanceId19(const std::string& instanceId19);
std::string getInstanceId14()const;
void setInstanceId14(const std::string& instanceId14);
std::string getInstanceId13()const;
void setInstanceId13(const std::string& instanceId13);
std::string getInstanceId16()const;
void setInstanceId16(const std::string& instanceId16);
std::string getInstanceId15()const;
void setInstanceId15(const std::string& instanceId15);
std::vector<std::string> getInstanceId() const;
void setInstanceId(const std::vector<std::string> &instanceId);
std::vector<int> getLoadBalancerWeight() const;
void setLoadBalancerWeight(const std::vector<int> &loadBalancerWeight);
bool getLifecycleHook() const;
void setLifecycleHook(bool lifecycleHook);
private:
int loadBalancerWeight6_;
int loadBalancerWeight11_;
int loadBalancerWeight7_;
int loadBalancerWeight12_;
long resourceOwnerId_;
int loadBalancerWeight8_;
int loadBalancerWeight9_;
int loadBalancerWeight10_;
int loadBalancerWeight2_;
int loadBalancerWeight15_;
int loadBalancerWeight3_;
int loadBalancerWeight16_;
int loadBalancerWeight4_;
int loadBalancerWeight13_;
int loadBalancerWeight5_;
int loadBalancerWeight14_;
int loadBalancerWeight1_;
std::string instanceId1_;
int loadBalancerWeight20_;
std::string instanceId3_;
std::string instanceId2_;
std::string instanceId5_;
std::string instanceId4_;
std::string instanceId7_;
std::string instanceId6_;
std::string instanceId9_;
std::string instanceId8_;
long ownerId_;
int loadBalancerWeight19_;
int loadBalancerWeight17_;
int loadBalancerWeight18_;
std::string instanceId10_;
std::string instanceId12_;
std::string instanceId11_;
std::string clientToken_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string instanceId20_;
std::string regionId_;
bool ignoreInvalidInstance_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
bool entrusted_;
std::string instanceId18_;
std::string instanceId17_;
std::string instanceId19_;
std::string instanceId14_;
std::string instanceId13_;
std::string instanceId16_;
std::string instanceId15_;
std::vector<std::string> instanceId_;
std::vector<int> loadBalancerWeight_;
bool lifecycleHook_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHINSTANCESREQUEST_H_

36
ess/include/alibabacloud/ess/model/AttachLoadBalancersRequest.h
View File

@@ -17,30 +17,31 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ATTACHLOADBALANCERSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHLOADBALANCERSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT AttachLoadBalancersRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT AttachLoadBalancersRequest : public RpcServiceRequest {
public:
struct LoadBalancerConfig {
std::string loadBalancerId;
int weight;
};
AttachLoadBalancersRequest();
~AttachLoadBalancersRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
bool getForceAttach() const;
void setForceAttach(bool forceAttach);
std::vector<LoadBalancerConfig> getLoadBalancerConfig() const;
void setLoadBalancerConfig(const std::vector<LoadBalancerConfig> &loadBalancerConfig);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::vector<std::string> getLoadBalancer() const;
@@ -49,18 +50,21 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getAsync() const;
void setAsync(bool async);
private:
std::string clientToken_;
std::string scalingGroupId_;
bool forceAttach_;
std::vector<LoadBalancerConfig> loadBalancerConfig_;
std::string accessKeyId_;
std::vector<std::string> loadBalancer_;
std::string resourceOwnerAccount_;
long ownerId_;
bool async_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHLOADBALANCERSREQUEST_H_

2
ess/include/alibabacloud/ess/model/AttachLoadBalancersResult.h
View File

@@ -37,10 +37,12 @@ namespace AlibabaCloud
AttachLoadBalancersResult();
explicit AttachLoadBalancersResult(const std::string &payload);
~AttachLoadBalancersResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}

69
ess/include/alibabacloud/ess/model/AttachServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_ATTACHSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHSERVERGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT AttachServerGroupsRequest : public RpcServiceRequest {
public:
struct ServerGroup {
std::string serverGroupId;
int port;
int weight;
std::string type;
};
AttachServerGroupsRequest();
~AttachServerGroupsRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
bool getForceAttach() const;
void setForceAttach(bool forceAttach);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<ServerGroup> getServerGroup() const;
void setServerGroup(const std::vector<ServerGroup> &serverGroup);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
std::string clientToken_;
std::string scalingGroupId_;
bool forceAttach_;
std::string accessKeyId_;
std::string regionId_;
std::vector<ServerGroup> serverGroup_;
std::string resourceOwnerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHSERVERGROUPSREQUEST_H_

51
ess/include/alibabacloud/ess/model/AttachServerGroupsResult.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_ESS_MODEL_ATTACHSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT AttachServerGroupsResult : public ServiceResult
{
public:
AttachServerGroupsResult();
explicit AttachServerGroupsResult(const std::string &payload);
~AttachServerGroupsResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHSERVERGROUPSRESULT_H_

33
ess/include/alibabacloud/ess/model/AttachVServerGroupsRequest.h
View File

@@ -17,36 +17,28 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ATTACHVSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ATTACHVSERVERGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT AttachVServerGroupsRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT AttachVServerGroupsRequest : public RpcServiceRequest {
public:
struct VServerGroup
{
struct VServerGroup {
std::string loadBalancerId;
struct VServerGroupAttribute
{
struct VServerGroupAttribute {
std::string vServerGroupId;
int port;
int weight;
};
std::vector<VServerGroupAttribute> vServerGroupAttribute;
};
public:
AttachVServerGroupsRequest();
~AttachVServerGroupsRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
@@ -73,9 +65,8 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::vector<VServerGroup> vServerGroup_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHVSERVERGROUPSREQUEST_H_

60
ess/include/alibabacloud/ess/model/ChangeResourceGroupRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_ESS_MODEL_CHANGERESOURCEGROUPREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CHANGERESOURCEGROUPREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ChangeResourceGroupRequest : public RpcServiceRequest {
public:
ChangeResourceGroupRequest();
~ChangeResourceGroupRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceId() const;
void setResourceId(const std::string &resourceId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getNewResourceGroupId() const;
void setNewResourceGroupId(const std::string &newResourceGroupId);
private:
std::string accessKeyId_;
std::string regionId_;
std::string resourceId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
std::string newResourceGroupId_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CHANGERESOURCEGROUPREQUEST_H_

49
ess/include/alibabacloud/ess/model/ChangeResourceGroupResult.h Normal file
View File

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

29
ess/include/alibabacloud/ess/model/CompleteLifecycleActionRequest.h
View File

@@ -17,30 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CompleteLifecycleActionRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CompleteLifecycleActionRequest : public RpcServiceRequest {
public:
CompleteLifecycleActionRequest();
~CompleteLifecycleActionRequest();
std::string getLifecycleActionToken() const;
void setLifecycleActionToken(const std::string &lifecycleActionToken);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getLifecycleHookId() const;
@@ -56,14 +53,14 @@ namespace AlibabaCloud
std::string lifecycleActionToken_;
std::string clientToken_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string lifecycleHookId_;
std::string ownerAccount_;
long ownerId_;
std::string lifecycleActionResult_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONREQUEST_H_

46
ess/include/alibabacloud/ess/model/CreateAlarmRequest.h
View File

@@ -17,42 +17,42 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateAlarmRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateAlarmRequest : public RpcServiceRequest {
public:
struct Dimension
{
struct Dimension {
std::string dimensionValue;
std::string dimensionKey;
};
public:
struct Expression {
int period;
float threshold;
std::string metricName;
std::string comparisonOperator;
std::string statistics;
};
CreateAlarmRequest();
~CreateAlarmRequest();
std::string getMetricType() const;
void setMetricType(const std::string &metricType);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getExpressionsLogicOperator() const;
void setExpressionsLogicOperator(const std::string &expressionsLogicOperator);
std::vector<std::string> getAlarmAction() const;
void setAlarmAction(const std::vector<std::string> &alarmAction);
float getThreshold() const;
void setThreshold(float threshold);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getEffective() const;
void setEffective(const std::string &effective);
std::string getRegionId() const;
@@ -65,6 +65,8 @@ namespace AlibabaCloud
void setDimension(const std::vector<Dimension> &dimension);
int getPeriod() const;
void setPeriod(int period);
std::vector<Expression> getExpression() const;
void setExpression(const std::vector<Expression> &expression);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
int getGroupId() const;
@@ -82,24 +84,24 @@ namespace AlibabaCloud
std::string metricType_;
std::string scalingGroupId_;
std::string description_;
std::string expressionsLogicOperator_;
std::vector<std::string> alarmAction_;
float threshold_;
std::string accessKeyId_;
std::string effective_;
std::string regionId_;
int evaluationCount_;
std::string metricName_;
std::vector<Dimension> dimension_;
int period_;
std::vector<Expression> expression_;
std::string resourceOwnerAccount_;
int groupId_;
long ownerId_;
std::string name_;
std::string comparisonOperator_;
std::string statistics_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_

334
ess/include/alibabacloud/ess/model/CreateEciScalingConfigurationRequest.h Normal file
View File

@@ -0,0 +1,334 @@
/*
* 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_ESS_MODEL_CREATEECISCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATEECISCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateEciScalingConfigurationRequest : public RpcServiceRequest {
public:
struct Container {
bool stdin;
int lifecyclePostStartHandlerHttpGetPort;
std::string workingDir;
int readinessProbeHttpGetPort;
int livenessProbeHttpGetPort;
int lifecyclePreStopHandlerTcpSocketPort;
struct VolumeMount {
std::string mountPath;
bool readOnly;
std::string mountPropagation;
std::string name;
std::string subPath;
};
std::vector<VolumeMount> volumeMount;
std::string image;
float cpu;
std::string readinessProbeHttpGetPath;
int gpu;
bool stdinOnce;
std::string lifecyclePostStartHandlerTcpSocketHost;
int livenessProbeSuccessThreshold;
long securityContextRunAsUser;
int livenessProbePeriodSeconds;
int livenessProbeInitialDelaySeconds;
struct Port {
std::string protocol;
int port;
};
std::vector<Port> port;
std::string name;
std::string lifecyclePreStopHandlerTcpSocketHost;
bool securityContextReadOnlyRootFilesystem;
std::string lifecyclePreStopHandlerHttpGetHost;
float memory;
std::string lifecyclePreStopHandlerHttpGetScheme;
int lifecyclePostStartHandlerTcpSocketPort;
std::string lifecyclePreStopHandlerHttpGetPath;
std::string lifecyclePostStartHandlerHttpGetHost;
int readinessProbeFailureThreshold;
int readinessProbeSuccessThreshold;
std::string lifecyclePostStartHandlerHttpGetPath;
int readinessProbeInitialDelaySeconds;
std::string readinessProbeHttpGetScheme;
int lifecyclePreStopHandlerHttpGetPort;
std::string imagePullPolicy;
std::string livenessProbeHttpGetPath;
std::string lifecyclePostStartHandlerHttpGetScheme;
int livenessProbeTimeoutSeconds;
int livenessProbeTcpSocketPort;
int readinessProbePeriodSeconds;
struct EnvironmentVar {
std::string fieldRefFieldPath;
std::string value;
std::string key;
};
std::vector<EnvironmentVar> environmentVar;
bool tty;
int livenessProbeFailureThreshold;
int readinessProbeTimeoutSeconds;
int readinessProbeTcpSocketPort;
std::string livenessProbeHttpGetScheme;
};
struct HostAliase {
std::string ip;
};
struct Tag {
std::string value;
std::string key;
};
struct Volume {
std::string diskVolumeFsType;
std::string emptyDirVolumeSizeLimit;
std::string nFSVolumePath;
std::string diskVolumeDiskId;
std::string flexVolumeFsType;
std::string type;
std::string flexVolumeDriver;
std::string flexVolumeOptions;
std::string nFSVolumeServer;
std::string emptyDirVolumeMedium;
std::string hostPathVolumePath;
std::string name;
struct ConfigFileVolumeConfigFileToPath {
int mode;
std::string path;
std::string content;
};
std::vector<ConfigFileVolumeConfigFileToPath> configFileVolumeConfigFileToPath;
int diskVolumeDiskSize;
int configFileVolumeDefaultMode;
std::string hostPathVolumeType;
bool nFSVolumeReadOnly;
};
struct DnsConfigOption {
std::string name;
std::string value;
};
struct SecurityContextSysctl {
std::string name;
std::string value;
};
struct InitContainer {
std::string image;
struct InitContainerEnvironmentVar {
std::string fieldRefFieldPath;
std::string value;
std::string key;
};
std::vector<InitContainerEnvironmentVar> initContainerEnvironmentVar;
float memory;
std::string workingDir;
float cpu;
int gpu;
std::string imagePullPolicy;
long securityContextRunAsUser;
struct InitContainerPort {
std::string protocol;
int port;
};
std::vector<InitContainerPort> initContainerPort;
std::string name;
struct InitContainerVolumeMount {
std::string mountPath;
bool readOnly;
std::string mountPropagation;
std::string name;
std::string subPath;
};
std::vector<InitContainerVolumeMount> initContainerVolumeMount;
bool securityContextReadOnlyRootFilesystem;
};
struct ImageRegistryCredential {
std::string server;
std::string password;
std::string userName;
};
struct AcrRegistryInfo {
std::string instanceName;
std::string instanceId;
std::string regionId;
};
CreateEciScalingConfigurationRequest();
~CreateEciScalingConfigurationRequest();
std::vector<Container> getContainer() const;
void setContainer(const std::vector<Container> &container);
std::vector<std::string> getNtpServer() const;
void setNtpServer(const std::vector<std::string> &ntpServer);
float getSpotPriceLimit() const;
void setSpotPriceLimit(float spotPriceLimit);
bool getEnableSls() const;
void setEnableSls(bool enableSls);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getHostName() const;
void setHostName(const std::string &hostName);
long getActiveDeadlineSeconds() const;
void setActiveDeadlineSeconds(long activeDeadlineSeconds);
long getEgressBandwidth() const;
void setEgressBandwidth(long egressBandwidth);
std::vector<std::string> getDnsConfigSearch() const;
void setDnsConfigSearch(const std::vector<std::string> &dnsConfigSearch);
std::vector<HostAliase> getHostAliase() const;
void setHostAliase(const std::vector<HostAliase> &hostAliase);
std::string getImageSnapshotId() const;
void setImageSnapshotId(const std::string &imageSnapshotId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
int getCpuOptionsThreadsPerCore() const;
void setCpuOptionsThreadsPerCore(int cpuOptionsThreadsPerCore);
std::string getDataCachePL() const;
void setDataCachePL(const std::string &dataCachePL);
int getIpv6AddressCount() const;
void setIpv6AddressCount(int ipv6AddressCount);
float getCpu() const;
void setCpu(float cpu);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationName() const;
void setScalingConfigurationName(const std::string &scalingConfigurationName);
std::string getSpotStrategy() const;
void setSpotStrategy(const std::string &spotStrategy);
std::vector<Volume> getVolume() const;
void setVolume(const std::vector<Volume> &volume);
std::string getInstanceFamilyLevel() const;
void setInstanceFamilyLevel(const std::string &instanceFamilyLevel);
std::vector<DnsConfigOption> getDnsConfigOption() const;
void setDnsConfigOption(const std::vector<DnsConfigOption> &dnsConfigOption);
int getEphemeralStorage() const;
void setEphemeralStorage(int ephemeralStorage);
int getDataCacheProvisionedIops() const;
void setDataCacheProvisionedIops(int dataCacheProvisionedIops);
int getEipBandwidth() const;
void setEipBandwidth(int eipBandwidth);
std::string getGpuDriverVersion() const;
void setGpuDriverVersion(const std::string &gpuDriverVersion);
bool getCostOptimization() const;
void setCostOptimization(bool costOptimization);
bool getDataCacheBurstingEnabled() const;
void setDataCacheBurstingEnabled(bool dataCacheBurstingEnabled);
float getMemory() const;
void setMemory(float memory);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::string getDescription() const;
void setDescription(const std::string &description);
long getIngressBandwidth() const;
void setIngressBandwidth(long ingressBandwidth);
std::string getDnsPolicy() const;
void setDnsPolicy(const std::string &dnsPolicy);
std::vector<SecurityContextSysctl> getSecurityContextSysctl() const;
void setSecurityContextSysctl(const std::vector<SecurityContextSysctl> &securityContextSysctl);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getDataCacheBucket() const;
void setDataCacheBucket(const std::string &dataCacheBucket);
std::vector<std::string> getDnsConfigNameServer() const;
void setDnsConfigNameServer(const std::vector<std::string> &dnsConfigNameServer);
std::vector<InitContainer> getInitContainer() const;
void setInitContainer(const std::vector<InitContainer> &initContainer);
std::vector<std::string> getInstanceType() const;
void setInstanceType(const std::vector<std::string> &instanceType);
long getTerminationGracePeriodSeconds() const;
void setTerminationGracePeriodSeconds(long terminationGracePeriodSeconds);
std::vector<ImageRegistryCredential> getImageRegistryCredential() const;
void setImageRegistryCredential(const std::vector<ImageRegistryCredential> &imageRegistryCredential);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getRestartPolicy() const;
void setRestartPolicy(const std::string &restartPolicy);
int getCpuOptionsCore() const;
void setCpuOptionsCore(int cpuOptionsCore);
std::string getRamRoleName() const;
void setRamRoleName(const std::string &ramRoleName);
std::vector<AcrRegistryInfo> getAcrRegistryInfo() const;
void setAcrRegistryInfo(const std::vector<AcrRegistryInfo> &acrRegistryInfo);
bool getAutoMatchImageCache() const;
void setAutoMatchImageCache(bool autoMatchImageCache);
int getLoadBalancerWeight() const;
void setLoadBalancerWeight(int loadBalancerWeight);
std::string getContainerGroupName() const;
void setContainerGroupName(const std::string &containerGroupName);
bool getAutoCreateEip() const;
void setAutoCreateEip(bool autoCreateEip);
private:
std::vector<Container> container_;
std::vector<std::string> ntpServer_;
float spotPriceLimit_;
bool enableSls_;
std::string resourceGroupId_;
std::string hostName_;
long activeDeadlineSeconds_;
long egressBandwidth_;
std::vector<std::string> dnsConfigSearch_;
std::vector<HostAliase> hostAliase_;
std::string imageSnapshotId_;
std::vector<Tag> tag_;
int cpuOptionsThreadsPerCore_;
std::string dataCachePL_;
int ipv6AddressCount_;
float cpu_;
long ownerId_;
std::string scalingConfigurationName_;
std::string spotStrategy_;
std::vector<Volume> volume_;
std::string instanceFamilyLevel_;
std::vector<DnsConfigOption> dnsConfigOption_;
int ephemeralStorage_;
int dataCacheProvisionedIops_;
int eipBandwidth_;
std::string gpuDriverVersion_;
bool costOptimization_;
bool dataCacheBurstingEnabled_;
float memory_;
std::string scalingGroupId_;
std::string securityGroupId_;
std::string description_;
long ingressBandwidth_;
std::string dnsPolicy_;
std::vector<SecurityContextSysctl> securityContextSysctl_;
std::string accessKeyId_;
std::string dataCacheBucket_;
std::vector<std::string> dnsConfigNameServer_;
std::vector<InitContainer> initContainer_;
std::vector<std::string> instanceType_;
long terminationGracePeriodSeconds_;
std::vector<ImageRegistryCredential> imageRegistryCredential_;
std::string resourceOwnerAccount_;
std::string restartPolicy_;
int cpuOptionsCore_;
std::string ramRoleName_;
std::vector<AcrRegistryInfo> acrRegistryInfo_;
bool autoMatchImageCache_;
int loadBalancerWeight_;
std::string containerGroupName_;
bool autoCreateEip_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATEECISCALINGCONFIGURATIONREQUEST_H_

51
ess/include/alibabacloud/ess/model/CreateEciScalingConfigurationResult.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_ESS_MODEL_CREATEECISCALINGCONFIGURATIONRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_CREATEECISCALINGCONFIGURATIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateEciScalingConfigurationResult : public ServiceResult
{
public:
CreateEciScalingConfigurationResult();
explicit CreateEciScalingConfigurationResult(const std::string &payload);
~CreateEciScalingConfigurationResult();
std::string getScalingConfigurationId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingConfigurationId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_CREATEECISCALINGCONFIGURATIONRESULT_H_

26
ess/include/alibabacloud/ess/model/CreateLifecycleHookRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateLifecycleHookRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateLifecycleHookRequest : public RpcServiceRequest {
public:
CreateLifecycleHookRequest();
~CreateLifecycleHookRequest();
std::string getDefaultResult() const;
void setDefaultResult(const std::string &defaultResult);
int getHeartbeatTimeout() const;
@@ -70,9 +65,8 @@ namespace AlibabaCloud
std::string ownerAccount_;
std::string notificationMetadata_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKREQUEST_H_

32
ess/include/alibabacloud/ess/model/CreateNotificationConfigurationRequest.h
View File

@@ -17,28 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATENOTIFICATIONCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATENOTIFICATIONCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateNotificationConfigurationRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateNotificationConfigurationRequest : public RpcServiceRequest {
public:
CreateNotificationConfigurationRequest();
~CreateNotificationConfigurationRequest();
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getTimeZone() const;
void setTimeZone(const std::string &timeZone);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNotificationArn() const;
void setNotificationArn(const std::string &notificationArn);
std::string getResourceOwnerAccount() const;
@@ -50,14 +49,15 @@ namespace AlibabaCloud
private:
std::string scalingGroupId_;
std::string timeZone_;
std::string accessKeyId_;
std::string regionId_;
std::string notificationArn_;
std::string resourceOwnerAccount_;
long ownerId_;
std::vector<std::string> notificationType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATENOTIFICATIONCONFIGURATIONREQUEST_H_

162
ess/include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h
View File

@@ -17,51 +17,93 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateScalingConfigurationRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateScalingConfigurationRequest : public RpcServiceRequest {
public:
struct SpotPriceLimit
{
struct SecurityOptions {
std::string confidentialComputingMode;
};
struct SpotPriceLimit {
std::string instanceType;
float priceLimit;
};
struct DataDisk
{
std::string diskName;
struct CustomPriorities {
std::string vswitchId;
std::string instanceType;
};
struct CpuOptions {
std::string string;
std::vector<std::string> accelerators;
};
struct InstancePatternInfo {
float memory;
int maximumCpuCoreCount;
float maxPrice;
int minimumGpuAmount;
int maximumGpuAmount;
float maximumMemorySize;
int minimumInitialCredit;
int minimumEniIpv6AddressQuantity;
int minimumEniPrivateIpAddressQuantity;
std::string burstablePerformance;
int minimumCpuCoreCount;
int minimumEniQuantity;
float minimumMemorySize;
int cores;
std::string instanceFamilyLevel;
int minimumBaselineCredit;
};
struct NetworkInterfaces {
int ipv6AddressCount;
std::string instanceType;
std::string networkInterfaceTrafficMode;
};
struct ResourcePoolOptions {
std::string strategy;
std::string string;
std::vector<std::string> privatePoolIds;
};
struct DataDisk {
std::string snapshotId;
int size;
std::string encrypted;
std::string performanceLevel;
std::string autoSnapshotPolicyId;
std::string description;
bool burstingEnabled;
std::string diskName;
long provisionedIops;
std::string encrypted;
int size;
std::string category;
std::string kMSKeyId;
std::string device;
bool deleteWithInstance;
};
public:
struct InstanceTypeOverride {
int weightedCapacity;
std::string instanceType;
};
CreateScalingConfigurationRequest();
~CreateScalingConfigurationRequest();
std::string getHpcClusterId() const;
void setHpcClusterId(const std::string &hpcClusterId);
SecurityOptions getSecurityOptions() const;
void setSecurityOptions(const SecurityOptions &securityOptions);
std::string getSecurityEnhancementStrategy() const;
void setSecurityEnhancementStrategy(const std::string &securityEnhancementStrategy);
std::string getKeyPairName() const;
void setKeyPairName(const std::string &keyPairName);
std::vector<SpotPriceLimit> getSpotPriceLimit() const;
void setSpotPriceLimit(const std::vector<SpotPriceLimit> &spotPriceLimit);
bool getDeletionProtection() const;
void setDeletionProtection(bool deletionProtection);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getPrivatePoolOptionsMatchCriteria() const;
@@ -72,14 +114,22 @@ namespace AlibabaCloud
void setPassword(const std::string &password);
std::string getInstanceDescription() const;
void setInstanceDescription(const std::string &instanceDescription);
int getStorageSetPartitionNumber() const;
void setStorageSetPartitionNumber(int storageSetPartitionNumber);
std::vector<CustomPriorities> getCustomPriorities() const;
void setCustomPriorities(const std::vector<CustomPriorities> &customPriorities);
std::string getSystemDiskAutoSnapshotPolicyId() const;
void setSystemDiskAutoSnapshotPolicyId(const std::string &systemDiskAutoSnapshotPolicyId);
std::string getPrivatePoolOptionsId() const;
void setPrivatePoolOptionsId(const std::string &privatePoolOptionsId);
bool getImageOptionsLoginAsNonRoot() const;
void setImageOptionsLoginAsNonRoot(bool imageOptionsLoginAsNonRoot);
int getIpv6AddressCount() const;
void setIpv6AddressCount(int ipv6AddressCount);
int getCpu() const;
void setCpu(int cpu);
std::vector<std::string> getSystemDiskCategories() const;
void setSystemDiskCategories(const std::vector<std::string> &systemDiskCategories);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationName() const;
@@ -88,6 +138,10 @@ namespace AlibabaCloud
void setTags(const std::string &tags);
std::string getSpotStrategy() const;
void setSpotStrategy(const std::string &spotStrategy);
CpuOptions getCpuOptions() const;
void setCpuOptions(const CpuOptions &cpuOptions);
bool getSystemDiskBurstingEnabled() const;
void setSystemDiskBurstingEnabled(bool systemDiskBurstingEnabled);
std::string getInstanceName() const;
void setInstanceName(const std::string &instanceName);
std::string getInternetChargeType() const;
@@ -96,38 +150,54 @@ namespace AlibabaCloud
void setZoneId(const std::string &zoneId);
int getInternetMaxBandwidthIn() const;
void setInternetMaxBandwidthIn(int internetMaxBandwidthIn);
std::vector<InstancePatternInfo> getInstancePatternInfo() const;
void setInstancePatternInfo(const std::vector<InstancePatternInfo> &instancePatternInfo);
std::string getAffinity() const;
void setAffinity(const std::string &affinity);
std::vector<NetworkInterfaces> getNetworkInterfaces() const;
void setNetworkInterfaces(const std::vector<NetworkInterfaces> &networkInterfaces);
std::string getImageId() const;
void setImageId(const std::string &imageId);
int getMemory() const;
void setMemory(int memory);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getSpotInterruptionBehavior() const;
void setSpotInterruptionBehavior(const std::string &spotInterruptionBehavior);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::vector<std::string> getInstanceTypes()const;
void setInstanceTypes(const std::vector<std::string>& instanceTypes);
std::string getIoOptimized() const;
void setIoOptimized(const std::string &ioOptimized);
std::vector<std::string> getInstanceTypes() const;
void setInstanceTypes(const std::vector<std::string> &instanceTypes);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
int getInternetMaxBandwidthOut() const;
void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
std::string getSystemDiskKMSKeyId() const;
void setSystemDiskKMSKeyId(const std::string &systemDiskKMSKeyId);
std::string getSystemDiskCategory() const;
void setSystemDiskCategory(const std::string &systemDiskCategory);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getSystemDiskPerformanceLevel() const;
void setSystemDiskPerformanceLevel(const std::string &systemDiskPerformanceLevel);
std::string getUserData() const;
void setUserData(const std::string &userData);
bool getPasswordInherit() const;
void setPasswordInherit(bool passwordInherit);
ResourcePoolOptions getResourcePoolOptions() const;
void setResourcePoolOptions(const ResourcePoolOptions &resourcePoolOptions);
std::string getImageName() const;
void setImageName(const std::string &imageName);
std::string getHttpEndpoint() const;
void setHttpEndpoint(const std::string &httpEndpoint);
std::string getDedicatedHostClusterId() const;
void setDedicatedHostClusterId(const std::string &dedicatedHostClusterId);
std::string getInstanceType() const;
void setInstanceType(const std::string &instanceType);
std::map<std::string, std::string> getSchedulerOptions() const;
void setSchedulerOptions(const std::map<std::string, std::string>& schedulerOptions);
void setSchedulerOptions(std::map<std::string, std::string> schedulerOptions);
std::string getDeploymentSetId() const;
void setDeploymentSetId(const std::string &deploymentSetId);
std::string getResourceOwnerAccount() const;
@@ -140,59 +210,89 @@ namespace AlibabaCloud
void setSystemDiskDiskName(const std::string &systemDiskDiskName);
std::string getRamRoleName() const;
void setRamRoleName(const std::string &ramRoleName);
std::string getSystemDiskEncryptAlgorithm() const;
void setSystemDiskEncryptAlgorithm(const std::string &systemDiskEncryptAlgorithm);
std::string getDedicatedHostId() const;
void setDedicatedHostId(const std::string &dedicatedHostId);
std::string getCreditSpecification() const;
void setCreditSpecification(const std::string &creditSpecification);
int getSpotDuration() const;
void setSpotDuration(int spotDuration);
std::vector<std::string> getSecurityGroupIds() const;
void setSecurityGroupIds(const std::vector<std::string> &securityGroupIds);
std::vector<DataDisk> getDataDisk() const;
void setDataDisk(const std::vector<DataDisk> &dataDisk);
std::vector<InstanceTypeOverride> getInstanceTypeOverride() const;
void setInstanceTypeOverride(const std::vector<InstanceTypeOverride> &instanceTypeOverride);
long getSystemDiskProvisionedIops() const;
void setSystemDiskProvisionedIops(long systemDiskProvisionedIops);
int getLoadBalancerWeight() const;
void setLoadBalancerWeight(int loadBalancerWeight);
std::string getStorageSetId() const;
void setStorageSetId(const std::string &storageSetId);
int getSystemDiskSize() const;
void setSystemDiskSize(int systemDiskSize);
std::string getImageFamily() const;
void setImageFamily(const std::string &imageFamily);
std::string getHttpTokens() const;
void setHttpTokens(const std::string &httpTokens);
std::string getSystemDiskDescription() const;
void setSystemDiskDescription(const std::string &systemDiskDescription);
bool getSystemDiskEncrypted() const;
void setSystemDiskEncrypted(bool systemDiskEncrypted);
private:
std::string hpcClusterId_;
SecurityOptions securityOptions_;
std::string securityEnhancementStrategy_;
std::string keyPairName_;
std::vector<SpotPriceLimit> spotPriceLimit_;
bool deletionProtection_;
std::string resourceGroupId_;
std::string privatePoolOptionsMatchCriteria_;
std::string hostName_;
std::string password_;
std::string instanceDescription_;
int storageSetPartitionNumber_;
std::vector<CustomPriorities> customPriorities_;
std::string systemDiskAutoSnapshotPolicyId_;
std::string privatePoolOptionsId_;
bool imageOptionsLoginAsNonRoot_;
int ipv6AddressCount_;
int cpu_;
std::vector<std::string> systemDiskCategories_;
long ownerId_;
std::string scalingConfigurationName_;
std::string tags_;
std::string spotStrategy_;
CpuOptions cpuOptions_;
bool systemDiskBurstingEnabled_;
std::string instanceName_;
std::string internetChargeType_;
std::string zoneId_;
int internetMaxBandwidthIn_;
std::vector<InstancePatternInfo> instancePatternInfo_;
std::string affinity_;
std::vector<NetworkInterfaces> networkInterfaces_;
std::string imageId_;
int memory_;
std::string clientToken_;
std::string spotInterruptionBehavior_;
std::string scalingGroupId_;
std::vector<std::string> instanceTypes_;
std::string ioOptimized_;
std::vector<std::string> instanceTypes_;
std::string securityGroupId_;
int internetMaxBandwidthOut_;
std::string systemDiskKMSKeyId_;
std::string systemDiskCategory_;
std::string accessKeyId_;
std::string systemDiskPerformanceLevel_;
std::string userData_;
bool passwordInherit_;
ResourcePoolOptions resourcePoolOptions_;
std::string imageName_;
std::string httpEndpoint_;
std::string dedicatedHostClusterId_;
std::string instanceType_;
std::map<std::string, std::string> schedulerOptions_;
std::string deploymentSetId_;
@@ -201,17 +301,23 @@ namespace AlibabaCloud
std::string tenancy_;
std::string systemDiskDiskName_;
std::string ramRoleName_;
std::string systemDiskEncryptAlgorithm_;
std::string dedicatedHostId_;
std::string creditSpecification_;
int spotDuration_;
std::vector<std::string> securityGroupIds_;
std::vector<DataDisk> dataDisk_;
std::vector<InstanceTypeOverride> instanceTypeOverride_;
long systemDiskProvisionedIops_;
int loadBalancerWeight_;
std::string storageSetId_;
int systemDiskSize_;
std::string imageFamily_;
std::string httpTokens_;
std::string systemDiskDescription_;
bool systemDiskEncrypted_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_

135
ess/include/alibabacloud/ess/model/CreateScalingGroupRequest.h
View File

@@ -17,27 +17,46 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATESCALINGGROUPREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGGROUPREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateScalingGroupRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateScalingGroupRequest : public RpcServiceRequest {
public:
struct Tag
{
struct Tag {
bool propagate;
std::string value;
std::string key;
};
struct LifecycleHook
{
struct ServerGroup {
std::string serverGroupId;
int port;
int weight;
std::string type;
};
struct LaunchTemplateOverride {
int weightedCapacity;
std::string instanceType;
float spotPriceLimit;
};
struct CapacityOptions {
bool compensateWithOnDemand;
std::string priceComparisonMode;
int onDemandBaseCapacity;
bool spotAutoReplaceOnDemand;
int onDemandPercentageAboveBaseCapacity;
};
struct AlbServerGroup {
std::string albServerGroupId;
int port;
int weight;
};
struct LifecycleHook {
std::string defaultResult;
std::string lifecycleHookName;
int heartbeatTimeout;
@@ -45,32 +64,60 @@ namespace AlibabaCloud
std::string notificationMetadata;
std::string lifecycleTransition;
};
struct VServerGroup
{
struct SystemTag {
std::string scope;
std::string value;
std::string key;
bool spread;
};
struct LoadBalancerConfig {
std::string loadBalancerId;
struct VServerGroupAttribute
{
int weight;
};
struct DBInstance {
std::string dBInstanceId;
std::string type;
std::string attachMode;
};
struct VServerGroup {
std::string loadBalancerId;
struct VServerGroupAttribute {
std::string vServerGroupId;
int port;
int weight;
};
std::vector<VServerGroupAttribute> vServerGroupAttribute;
};
public:
CreateScalingGroupRequest();
~CreateScalingGroupRequest();
bool getAzBalance() const;
void setAzBalance(bool azBalance);
std::vector<std::string> getVSwitchIds() const;
void setVSwitchIds(const std::vector<std::string> &vSwitchIds);
int getMaxInstanceLifetime() const;
void setMaxInstanceLifetime(int maxInstanceLifetime);
bool getSpotInstanceRemedy() const;
void setSpotInstanceRemedy(bool spotInstanceRemedy);
bool getScaleOutAmountCheck() const;
void setScaleOutAmountCheck(bool scaleOutAmountCheck);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getGroupType() const;
void setGroupType(const std::string &groupType);
bool getSyncAlarmRuleToCms() const;
void setSyncAlarmRuleToCms(bool syncAlarmRuleToCms);
std::string getCustomPolicyARN() const;
void setCustomPolicyARN(const std::string &customPolicyARN);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
int getStopInstanceTimeout() const;
void setStopInstanceTimeout(int stopInstanceTimeout);
int getDefaultCooldown() const;
void setDefaultCooldown(int defaultCooldown);
std::vector<std::string> getHealthCheckTypes() const;
void setHealthCheckTypes(const std::vector<std::string> &healthCheckTypes);
std::string getContainerGroupId() const;
void setContainerGroupId(const std::string &containerGroupId);
std::string getMultiAZPolicy() const;
void setMultiAZPolicy(const std::string &multiAZPolicy);
std::string getDBInstanceIds() const;
@@ -79,12 +126,20 @@ namespace AlibabaCloud
void setLaunchTemplateId(const std::string &launchTemplateId);
int getDesiredCapacity() const;
void setDesiredCapacity(int desiredCapacity);
std::vector<ServerGroup> getServerGroup() const;
void setServerGroup(const std::vector<ServerGroup> &serverGroup);
std::vector<LaunchTemplateOverride> getLaunchTemplateOverride() const;
void setLaunchTemplateOverride(const std::vector<LaunchTemplateOverride> &launchTemplateOverride);
bool getCompensateWithOnDemand() const;
void setCompensateWithOnDemand(bool compensateWithOnDemand);
CapacityOptions getCapacityOptions() const;
void setCapacityOptions(const CapacityOptions &capacityOptions);
int getMinSize() const;
void setMinSize(int minSize);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<AlbServerGroup> getAlbServerGroup() const;
void setAlbServerGroup(const std::vector<AlbServerGroup> &albServerGroup);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
std::string getInstanceId() const;
@@ -97,18 +152,26 @@ namespace AlibabaCloud
void setLoadBalancerIds(const std::string &loadBalancerIds);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::vector<SystemTag> getSystemTag() const;
void setSystemTag(const std::vector<SystemTag> &systemTag);
std::vector<LoadBalancerConfig> getLoadBalancerConfig() const;
void setLoadBalancerConfig(const std::vector<LoadBalancerConfig> &loadBalancerConfig);
int getOnDemandBaseCapacity() const;
void setOnDemandBaseCapacity(int onDemandBaseCapacity);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
int getOnDemandPercentageAboveBaseCapacity() const;
void setOnDemandPercentageAboveBaseCapacity(int onDemandPercentageAboveBaseCapacity);
std::string getSpotAllocationStrategy() const;
void setSpotAllocationStrategy(const std::string &spotAllocationStrategy);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getRemovalPolicy1() const;
void setRemovalPolicy1(const std::string &removalPolicy1);
std::string getRemovalPolicy2() const;
void setRemovalPolicy2(const std::string &removalPolicy2);
std::string getRemovalPolicy3() const;
void setRemovalPolicy3(const std::string &removalPolicy3);
std::string getHealthCheckType() const;
void setHealthCheckType(const std::string &healthCheckType);
std::string getResourceOwnerAccount() const;
@@ -119,52 +182,74 @@ namespace AlibabaCloud
void setOwnerAccount(const std::string &ownerAccount);
int getSpotInstancePools() const;
void setSpotInstancePools(int spotInstancePools);
std::vector<DBInstance> getDBInstance() const;
void setDBInstance(const std::vector<DBInstance> &dBInstance);
bool getGroupDeletionProtection() const;
void setGroupDeletionProtection(bool groupDeletionProtection);
std::string getLaunchTemplateVersion() const;
void setLaunchTemplateVersion(const std::string &launchTemplateVersion);
std::string getScalingPolicy() const;
void setScalingPolicy(const std::string &scalingPolicy);
std::string getAllocationStrategy() const;
void setAllocationStrategy(const std::string &allocationStrategy);
std::vector<VServerGroup> getVServerGroup() const;
void setVServerGroup(const std::vector<VServerGroup> &vServerGroup);
private:
bool azBalance_;
std::vector<std::string> vSwitchIds_;
int maxInstanceLifetime_;
bool spotInstanceRemedy_;
bool scaleOutAmountCheck_;
std::string resourceGroupId_;
std::string groupType_;
bool syncAlarmRuleToCms_;
std::string customPolicyARN_;
std::vector<Tag> tag_;
int stopInstanceTimeout_;
int defaultCooldown_;
std::vector<std::string> healthCheckTypes_;
std::string containerGroupId_;
std::string multiAZPolicy_;
std::string dBInstanceIds_;
std::string launchTemplateId_;
int desiredCapacity_;
std::vector<ServerGroup> serverGroup_;
std::vector<LaunchTemplateOverride> launchTemplateOverride_;
bool compensateWithOnDemand_;
CapacityOptions capacityOptions_;
int minSize_;
long ownerId_;
std::vector<AlbServerGroup> albServerGroup_;
std::string vSwitchId_;
std::string instanceId_;
int maxSize_;
std::vector<LifecycleHook> lifecycleHook_;
std::string loadBalancerIds_;
std::string clientToken_;
std::vector<SystemTag> systemTag_;
std::vector<LoadBalancerConfig> loadBalancerConfig_;
int onDemandBaseCapacity_;
std::string accessKeyId_;
int onDemandPercentageAboveBaseCapacity_;
std::string spotAllocationStrategy_;
std::string regionId_;
std::string removalPolicy1_;
std::string removalPolicy2_;
std::string removalPolicy3_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;
std::string scalingGroupName_;
std::string ownerAccount_;
int spotInstancePools_;
std::vector<DBInstance> dBInstance_;
bool groupDeletionProtection_;
std::string launchTemplateVersion_;
std::string scalingPolicy_;
std::string allocationStrategy_;
std::vector<VServerGroup> vServerGroup_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGGROUPREQUEST_H_

62
ess/include/alibabacloud/ess/model/CreateScalingRuleRequest.h
View File

@@ -17,31 +17,43 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULEREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULEREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateScalingRuleRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateScalingRuleRequest : public RpcServiceRequest {
public:
struct StepAdjustment
{
float metricIntervalLowerBound;
struct AlarmDimension {
std::string dimensionValue;
std::string dimensionKey;
};
struct StepAdjustment {
float metricIntervalUpperBound;
float metricIntervalLowerBound;
int scalingAdjustment;
};
public:
struct HybridMetrics {
std::string statistic;
std::string expression;
std::string id;
std::string metricName;
struct Dimensions {
std::string dimensionValue;
std::string dimensionKey;
};
std::vector<Dimensions> dimensions;
};
CreateScalingRuleRequest();
~CreateScalingRuleRequest();
std::string getMetricType() const;
void setMetricType(const std::string &metricType);
std::vector<AlarmDimension> getAlarmDimension() const;
void setAlarmDimension(const std::vector<AlarmDimension> &alarmDimension);
std::vector<StepAdjustment> getStepAdjustment() const;
void setStepAdjustment(const std::vector<StepAdjustment> &stepAdjustment);
std::string getScalingGroupId() const;
@@ -54,6 +66,10 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string &accessKeyId);
std::string getScalingRuleName() const;
void setScalingRuleName(const std::string &scalingRuleName);
std::string getHybridMonitorNamespace() const;
void setHybridMonitorNamespace(const std::string &hybridMonitorNamespace);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getCooldown() const;
void setCooldown(int cooldown);
std::string getPredictiveValueBehavior() const;
@@ -82,6 +98,8 @@ namespace AlibabaCloud
void setOwnerId(long ownerId);
int getPredictiveValueBuffer() const;
void setPredictiveValueBuffer(int predictiveValueBuffer);
std::vector<HybridMetrics> getHybridMetrics() const;
void setHybridMetrics(const std::vector<HybridMetrics> &hybridMetrics);
int getScaleOutEvaluationCount() const;
void setScaleOutEvaluationCount(int scaleOutEvaluationCount);
int getMinAdjustmentMagnitude() const;
@@ -90,12 +108,16 @@ namespace AlibabaCloud
void setTargetValue(float targetValue);
private:
std::string metricType_;
std::vector<AlarmDimension> alarmDimension_;
std::vector<StepAdjustment> stepAdjustment_;
std::string scalingGroupId_;
bool disableScaleIn_;
int initialMaxSize_;
std::string accessKeyId_;
std::string scalingRuleName_;
std::string hybridMonitorNamespace_;
std::string regionId_;
int cooldown_;
std::string predictiveValueBehavior_;
int scaleInEvaluationCount_;
@@ -110,12 +132,12 @@ namespace AlibabaCloud
std::string adjustmentType_;
long ownerId_;
int predictiveValueBuffer_;
std::vector<HybridMetrics> hybridMetrics_;
int scaleOutEvaluationCount_;
int minAdjustmentMagnitude_;
float targetValue_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULEREQUEST_H_

26
ess/include/alibabacloud/ess/model/CreateScheduledTaskRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_CREATESCHEDULEDTASKREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATESCHEDULEDTASKREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT CreateScheduledTaskRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT CreateScheduledTaskRequest : public RpcServiceRequest {
public:
CreateScheduledTaskRequest();
~CreateScheduledTaskRequest();
std::string getScheduledAction() const;
void setScheduledAction(const std::string &scheduledAction);
int getMaxValue() const;
@@ -91,9 +86,8 @@ namespace AlibabaCloud
std::string scheduledTaskName_;
bool taskEnabled_;
std::string recurrenceType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCHEDULEDTASKREQUEST_H_

32
ess/include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h
View File

@@ -17,44 +17,38 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DEACTIVATESCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DEACTIVATESCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeactivateScalingConfigurationRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeactivateScalingConfigurationRequest : public RpcServiceRequest {
public:
DeactivateScalingConfigurationRequest();
~DeactivateScalingConfigurationRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScalingConfigurationId() const;
void setScalingConfigurationId(const std::string &scalingConfigurationId);
private:
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string scalingConfigurationId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DEACTIVATESCALINGCONFIGURATIONREQUEST_H_

38
ess/include/alibabacloud/ess/model/DeleteAlarmRequest.h
View File

@@ -17,44 +17,38 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETEALARMREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteAlarmRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteAlarmRequest : public RpcServiceRequest {
public:
DeleteAlarmRequest();
~DeleteAlarmRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAlarmTaskId() const;
void setAlarmTaskId(const std::string &alarmTaskId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
std::string regionId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETEALARMREQUEST_H_

57
ess/include/alibabacloud/ess/model/DeleteEciScalingConfigurationRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_DELETEECISCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETEECISCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteEciScalingConfigurationRequest : public RpcServiceRequest {
public:
DeleteEciScalingConfigurationRequest();
~DeleteEciScalingConfigurationRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationId() const;
void setScalingConfigurationId(const std::string &scalingConfigurationId);
private:
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string scalingConfigurationId_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETEECISCALINGCONFIGURATIONREQUEST_H_

49
ess/include/alibabacloud/ess/model/DeleteEciScalingConfigurationResult.h Normal file
View File

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

29
ess/include/alibabacloud/ess/model/DeleteLifecycleHookRequest.h
View File

@@ -17,30 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteLifecycleHookRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteLifecycleHookRequest : public RpcServiceRequest {
public:
DeleteLifecycleHookRequest();
~DeleteLifecycleHookRequest();
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getLifecycleHookName() const;
void setLifecycleHookName(const std::string &lifecycleHookName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getLifecycleHookId() const;
@@ -54,13 +51,13 @@ namespace AlibabaCloud
std::string scalingGroupId_;
std::string accessKeyId_;
std::string lifecycleHookName_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string lifecycleHookId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKREQUEST_H_

41
ess/include/alibabacloud/ess/model/DeleteNotificationConfigurationRequest.h
View File

@@ -17,44 +17,41 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETENOTIFICATIONCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETENOTIFICATIONCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteNotificationConfigurationRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteNotificationConfigurationRequest : public RpcServiceRequest {
public:
DeleteNotificationConfigurationRequest();
~DeleteNotificationConfigurationRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNotificationArn() const;
void setNotificationArn(const std::string &notificationArn);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
std::string resourceOwnerAccount_;
std::string scalingGroupId_;
long ownerId_;
std::string accessKeyId_;
std::string regionId_;
std::string notificationArn_;
std::string resourceOwnerAccount_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETENOTIFICATIONCONFIGURATIONREQUEST_H_

32
ess/include/alibabacloud/ess/model/DeleteScalingConfigurationRequest.h
View File

@@ -17,44 +17,38 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETESCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETESCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteScalingConfigurationRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteScalingConfigurationRequest : public RpcServiceRequest {
public:
DeleteScalingConfigurationRequest();
~DeleteScalingConfigurationRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScalingConfigurationId() const;
void setScalingConfigurationId(const std::string &scalingConfigurationId);
private:
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string scalingConfigurationId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCALINGCONFIGURATIONREQUEST_H_

29
ess/include/alibabacloud/ess/model/DeleteScalingGroupRequest.h
View File

@@ -17,28 +17,25 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETESCALINGGROUPREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETESCALINGGROUPREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteScalingGroupRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteScalingGroupRequest : public RpcServiceRequest {
public:
DeleteScalingGroupRequest();
~DeleteScalingGroupRequest();
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
bool getForceDelete() const;
void setForceDelete(bool forceDelete);
std::string getResourceOwnerAccount() const;
@@ -51,13 +48,13 @@ namespace AlibabaCloud
private:
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
bool forceDelete_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCALINGGROUPREQUEST_H_

41
ess/include/alibabacloud/ess/model/DeleteScalingRuleRequest.h
View File

@@ -17,44 +17,41 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETESCALINGRULEREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETESCALINGRULEREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteScalingRuleRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteScalingRuleRequest : public RpcServiceRequest {
public:
DeleteScalingRuleRequest();
~DeleteScalingRuleRequest();
std::string getScalingRuleId() const;
void setScalingRuleId(const std::string &scalingRuleId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingRuleId()const;
void setScalingRuleId(const std::string& scalingRuleId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string scalingRuleId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string scalingRuleId_;
std::string accessKeyId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCALINGRULEREQUEST_H_

35
ess/include/alibabacloud/ess/model/DeleteScheduledTaskRequest.h
View File

@@ -17,44 +17,41 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DELETESCHEDULEDTASKREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETESCHEDULEDTASKREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DeleteScheduledTaskRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DeleteScheduledTaskRequest : public RpcServiceRequest {
public:
DeleteScheduledTaskRequest();
~DeleteScheduledTaskRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScheduledTaskId() const;
void setScheduledTaskId(const std::string &scheduledTaskId);
private:
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string scheduledTaskId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCHEDULEDTASKREQUEST_H_

29
ess/include/alibabacloud/ess/model/DescribeAlarmsRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeAlarmsRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeAlarmsRequest : public RpcServiceRequest {
public:
DescribeAlarmsRequest();
~DescribeAlarmsRequest();
std::string getMetricType() const;
void setMetricType(const std::string &metricType);
std::string getScalingGroupId() const;
@@ -49,6 +44,8 @@ namespace AlibabaCloud
void setPageSize(int pageSize);
std::string getState() const;
void setState(const std::string &state);
std::string getMetricName() const;
void setMetricName(const std::string &metricName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
@@ -66,13 +63,13 @@ namespace AlibabaCloud
std::string regionId_;
int pageSize_;
std::string state_;
std::string metricName_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string alarmTaskId_;
bool isEnable_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_

30
ess/include/alibabacloud/ess/model/DescribeAlarmsResult.h
View File

@@ -39,20 +39,46 @@ namespace AlibabaCloud
std::string dimensionValue;
std::string dimensionKey;
};
struct Expression
{
std::string metricName;
std::string comparisonOperator;
int period;
std::string statistics;
float threshold;
};
struct HybridMetric
{
struct Dimension2
{
std::string dimensionValue;
std::string dimensionKey;
};
std::string metricName;
std::string statistic;
std::string expression;
std::vector<HybridMetric::Dimension2> dimensions1;
std::string id;
};
std::string comparisonOperator;
std::string description;
std::string promQL;
std::string scalingGroupId;
std::string metricType;
std::vector<Alarm::Dimension> dimensions;
int period;
int evaluationCount;
int period;
std::vector<Alarm::HybridMetric> hybridMetrics;
std::string statistics;
std::string name;
std::string effective;
std::string name;
std::vector<std::string> alarmActions;
std::string metricName;
std::string expressionsLogicOperator;
std::string state;
std::string hybridMonitorNamespace;
bool enable;
std::vector<Alarm::Expression> expressions;
std::string alarmTaskId;
float threshold;
};

72
ess/include/alibabacloud/ess/model/DescribeEciScalingConfigurationsRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEECISCALINGCONFIGURATIONSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEECISCALINGCONFIGURATIONSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeEciScalingConfigurationsRequest : public RpcServiceRequest {
public:
DescribeEciScalingConfigurationsRequest();
~DescribeEciScalingConfigurationsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<std::string> getScalingConfigurationName() const;
void setScalingConfigurationName(const std::vector<std::string> &scalingConfigurationName);
std::vector<std::string> getScalingConfigurationId() const;
void setScalingConfigurationId(const std::vector<std::string> &scalingConfigurationId);
private:
long resourceOwnerId_;
std::string scalingGroupId_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::vector<std::string> scalingConfigurationName_;
std::vector<std::string> scalingConfigurationId_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEECISCALINGCONFIGURATIONSREQUEST_H_

282
ess/include/alibabacloud/ess/model/DescribeEciScalingConfigurationsResult.h Normal file
View File

@@ -0,0 +1,282 @@
/*
* 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_ESS_MODEL_DESCRIBEECISCALINGCONFIGURATIONSRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEECISCALINGCONFIGURATIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeEciScalingConfigurationsResult : public ServiceResult
{
public:
struct ScalingConfiguration
{
struct Container
{
struct Port
{
int port;
std::string protocol;
};
struct VolumeMount
{
bool readOnly;
std::string mountPath;
std::string subPath;
std::string mountPropagation;
std::string name;
};
struct EnvironmentVar
{
std::string fieldRefFieldPath;
std::string value;
std::string key;
};
std::vector<Container::EnvironmentVar> environmentVars;
std::vector<std::string> readinessProbeExecCommands;
float memory;
int readinessProbeTcpSocketPort;
std::string readinessProbeHttpGetPath;
float cpu;
std::string image;
std::string readinessProbeHttpGetScheme;
int gpu;
bool stdinOnce;
std::string lifecyclePreStopHandlerTcpSocketHost;
std::string name;
std::string lifecyclePostStartHandlerHttpGetHost;
bool securityContextReadOnlyRootFilesystem;
std::string lifecyclePostStartHandlerHttpGetPath;
int livenessProbePeriodSeconds;
std::vector<std::string> livenessProbeExecCommands;
int readinessProbeSuccessThreshold;
int readinessProbeInitialDelaySeconds;
std::string lifecyclePreStopHandlerHttpGetScheme;
std::vector<std::string> securityContextCapabilityAdds;
int lifecyclePreStopHandlerHttpGetPort;
bool stdin;
std::string workingDir;
std::string lifecyclePostStartHandlerHttpGetScheme;
int readinessProbeTimeoutSeconds;
std::vector<std::string> lifecyclePostStartHandlerExecs;
std::string lifecyclePreStopHandlerHttpGetHost;
int lifecyclePostStartHandlerHttpGetPort;
std::string lifecyclePreStopHandlerHttpGetPath;
std::string livenessProbeHttpGetScheme;
int livenessProbeTimeoutSeconds;
int livenessProbeFailureThreshold;
std::string livenessProbeHttpGetPath;
std::vector<Container::VolumeMount> volumeMounts;
int livenessProbeInitialDelaySeconds;
int livenessProbeTcpSocketPort;
bool tty;
long securityContextRunAsUser;
std::vector<std::string> commands;
int readinessProbePeriodSeconds;
std::vector<std::string> lifecyclePreStopHandlerExecs;
int livenessProbeSuccessThreshold;
std::string lifecyclePostStartHandlerTcpSocketHost;
int lifecyclePreStopHandlerTcpSocketPort;
std::vector<std::string> args;
int readinessProbeFailureThreshold;
std::vector<Container::Port> ports;
int readinessProbeHttpGetPort;
std::string imagePullPolicy;
int livenessProbeHttpGetPort;
int lifecyclePostStartHandlerTcpSocketPort;
};
struct InitContainer
{
struct InitContainerEnvironmentVar
{
std::string fieldRefFieldPath;
std::string value;
std::string key;
};
struct InitContainerPort
{
int port;
std::string protocol;
};
struct InitContainerVolumeMount
{
bool readOnly;
std::string mountPath;
std::string subPath;
std::string mountPropagation;
std::string name;
};
std::vector<std::string> initContainerArgs;
float memory;
std::vector<InitContainer::InitContainerPort> initContainerPorts;
float cpu;
std::string image;
int gpu;
std::vector<InitContainer::InitContainerEnvironmentVar> initContainerEnvironmentVars;
std::string name;
std::string workingDir;
std::vector<std::string> initContainerCommands;
std::string imagePullPolicy;
bool securityContextReadOnlyRootFilesystem;
std::string securityContextRunAsUser;
std::vector<InitContainer::InitContainerVolumeMount> initContainerVolumeMounts;
std::vector<std::string> securityContextCapabilityAdds1;
};
struct Tag
{
std::string value;
std::string key;
};
struct Volume
{
struct ConfigFileVolumeConfigFileToPath
{
std::string path;
std::string content;
int mode;
};
std::string hostPathVolumeType;
std::string flexVolumeFsType;
std::string emptyDirVolumeSizeLimit;
std::string nFSVolumeServer;
int diskVolumeDiskSize;
std::vector<Volume::ConfigFileVolumeConfigFileToPath> configFileVolumeConfigFileToPaths;
bool nFSVolumeReadOnly;
std::string name;
std::string hostPathVolumePath;
std::string nFSVolumePath;
std::string type;
std::string flexVolumeDriver;
std::string diskVolumeDiskId;
int configFileVolumeDefaultMode;
std::string flexVolumeOptions;
std::string emptyDirVolumeMedium;
std::string diskVolumeFsType;
};
struct ImageRegistryCredential
{
std::string userName;
std::string server;
std::string password;
};
struct DnsConfigOption
{
std::string value;
std::string name;
};
struct HostAlias
{
std::string ip;
std::vector<std::string> hostnames;
};
struct SecurityContextSysCtl
{
std::string value;
std::string name;
};
struct AcrRegistryInfo
{
std::string instanceName;
std::vector<std::string> domains;
std::string instanceId;
std::string regionId;
};
std::string scalingConfigurationName;
std::string resourceGroupId;
std::vector<std::string> ntpServers;
float memory;
std::vector<std::string> dnsConfigSearches;
std::string dataCachePL;
float cpu;
long ingressBandwidth;
int dataCacheProvisionedIops;
std::vector<ScalingConfiguration::Volume> volumes;
std::string ramRoleName;
std::vector<ScalingConfiguration::DnsConfigOption> dnsConfigOptions;
std::vector<ScalingConfiguration::Tag> tags;
std::string hostName;
std::vector<std::string> dnsConfigNameServers;
int activeDeadlineSeconds;
int loadBalancerWeight;
std::string scalingGroupId;
bool slsEnable;
int cpuOptionsCore;
bool autoCreateEip;
std::vector<ScalingConfiguration::HostAlias> hostAliases;
std::string gpuDriverVersion;
std::vector<ScalingConfiguration::ImageRegistryCredential> imageRegistryCredentials;
std::string dnsPolicy;
std::string creationTime;
std::string instanceFamilyLevel;
int ephemeralStorage;
std::string scalingConfigurationId;
std::string description;
std::vector<ScalingConfiguration::Container> containers;
std::string lifecycleState;
std::string containerGroupName;
std::string imageSnapshotId;
long egressBandwidth;
bool autoMatchImageCache;
int ipv6AddressCount;
std::string dataCacheBucket;
float spotPriceLimit;
std::vector<std::string> instanceTypes;
std::string spotStrategy;
std::vector<ScalingConfiguration::AcrRegistryInfo> acrRegistryInfos;
std::vector<ScalingConfiguration::InitContainer> initContainers;
std::vector<ScalingConfiguration::SecurityContextSysCtl> securityContextSysCtls;
int cpuOptionsThreadsPerCore;
bool dataCacheBurstingEnabled;
int terminationGracePeriodSeconds;
std::string securityGroupId;
std::string restartPolicy;
bool costOptimization;
int eipBandwidth;
std::string regionId;
};
DescribeEciScalingConfigurationsResult();
explicit DescribeEciScalingConfigurationsResult(const std::string &payload);
~DescribeEciScalingConfigurationsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<ScalingConfiguration> getScalingConfigurations()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<ScalingConfiguration> scalingConfigurations_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEECISCALINGCONFIGURATIONSRESULT_H_

81
ess/include/alibabacloud/ess/model/DescribeElasticStrengthRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEELASTICSTRENGTHREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEELASTICSTRENGTHREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeElasticStrengthRequest : public RpcServiceRequest {
public:
DescribeElasticStrengthRequest();
~DescribeElasticStrengthRequest();
std::string getImageId() const;
void setImageId(const std::string &imageId);
std::vector<std::string> getDataDiskCategories() const;
void setDataDiskCategories(const std::vector<std::string> &dataDiskCategories);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::vector<std::string> getVSwitchIds() const;
void setVSwitchIds(const std::vector<std::string> &vSwitchIds);
std::vector<std::string> getInstanceTypes() const;
void setInstanceTypes(const std::vector<std::string> &instanceTypes);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getImageName() const;
void setImageName(const std::string &imageName);
std::vector<std::string> getScalingGroupIds() const;
void setScalingGroupIds(const std::vector<std::string> &scalingGroupIds);
int getIpv6AddressCount() const;
void setIpv6AddressCount(int ipv6AddressCount);
std::vector<std::string> getSystemDiskCategories() const;
void setSystemDiskCategories(const std::vector<std::string> &systemDiskCategories);
std::string getSpotStrategy() const;
void setSpotStrategy(const std::string &spotStrategy);
std::string getPriorityStrategy() const;
void setPriorityStrategy(const std::string &priorityStrategy);
std::string getImageFamily() const;
void setImageFamily(const std::string &imageFamily);
private:
std::string imageId_;
std::vector<std::string> dataDiskCategories_;
std::string scalingGroupId_;
std::vector<std::string> vSwitchIds_;
std::vector<std::string> instanceTypes_;
std::string accessKeyId_;
std::string regionId_;
std::string imageName_;
std::vector<std::string> scalingGroupIds_;
int ipv6AddressCount_;
std::vector<std::string> systemDiskCategories_;
std::string spotStrategy_;
std::string priorityStrategy_;
std::string imageFamily_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEELASTICSTRENGTHREQUEST_H_

100
ess/include/alibabacloud/ess/model/DescribeElasticStrengthResult.h Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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_ESS_MODEL_DESCRIBEELASTICSTRENGTHRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEELASTICSTRENGTHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeElasticStrengthResult : public ServiceResult
{
public:
struct ResourcePool
{
struct InventoryHealth
{
int healthScore;
int supplyScore;
int adequacyScore;
int hotScore;
};
std::string msg;
std::string status;
std::string zoneId;
std::vector<std::string> vSwitchIds;
InventoryHealth inventoryHealth;
std::string instanceType;
std::string code;
double strength;
};
struct ElasticStrengthModel
{
struct ResourcePool2
{
struct InventoryHealth4
{
int healthScore;
int supplyScore;
int adequacyScore;
int hotScore;
};
std::string msg;
std::string status;
std::string zoneId;
std::vector<std::string> vSwitchIds3;
InventoryHealth4 inventoryHealth4;
std::string instanceType;
std::string code;
double strength;
};
std::vector<ElasticStrengthModel::ResourcePool2> resourcePools1;
std::string scalingGroupId;
std::string elasticStrength;
double totalStrength;
};
DescribeElasticStrengthResult();
explicit DescribeElasticStrengthResult(const std::string &payload);
~DescribeElasticStrengthResult();
std::vector<ResourcePool> getResourcePools()const;
std::vector<ElasticStrengthModel> getElasticStrengthModels()const;
std::string getElasticStrength()const;
double getTotalStrength()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ResourcePool> resourcePools_;
std::vector<ElasticStrengthModel> elasticStrengthModels_;
std::string elasticStrength_;
double totalStrength_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEELASTICSTRENGTHRESULT_H_

29
ess/include/alibabacloud/ess/model/DescribeLifecycleActionsRequest.h
View File

@@ -17,30 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEACTIONSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEACTIONSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeLifecycleActionsRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeLifecycleActionsRequest : public RpcServiceRequest {
public:
DescribeLifecycleActionsRequest();
~DescribeLifecycleActionsRequest();
std::string getLifecycleActionStatus() const;
void setLifecycleActionStatus(const std::string &lifecycleActionStatus);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
@@ -54,13 +51,13 @@ namespace AlibabaCloud
std::string lifecycleActionStatus_;
std::string accessKeyId_;
std::string nextToken_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string scalingActivityId_;
int maxResults_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEACTIONSREQUEST_H_

29
ess/include/alibabacloud/ess/model/DescribeLifecycleHooksRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeLifecycleHooksRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeLifecycleHooksRequest : public RpcServiceRequest {
public:
DescribeLifecycleHooksRequest();
~DescribeLifecycleHooksRequest();
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
int getPageNumber() const;
@@ -43,6 +38,8 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string &accessKeyId);
std::string getLifecycleHookName() const;
void setLifecycleHookName(const std::string &lifecycleHookName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
@@ -59,14 +56,14 @@ namespace AlibabaCloud
int pageNumber_;
std::string accessKeyId_;
std::string lifecycleHookName_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::vector<std::string> lifecycleHookId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSREQUEST_H_

3
ess/include/alibabacloud/ess/model/DescribeLifecycleHooksResult.h
View File

@@ -34,10 +34,11 @@ namespace AlibabaCloud
public:
struct LifecycleHook
{
std::string lifecycleHookStatus;
std::string lifecycleHookName;
std::string notificationArn;
std::string scalingGroupId;
std::string lifecycleTransition;
std::string scalingGroupId;
int heartbeatTimeout;
std::string notificationMetadata;
std::string defaultResult;

26
ess/include/alibabacloud/ess/model/DescribeLimitationRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBELIMITATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIMITATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeLimitationRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeLimitationRequest : public RpcServiceRequest {
public:
DescribeLimitationRequest();
~DescribeLimitationRequest();
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
@@ -46,9 +41,8 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBELIMITATIONREQUEST_H_

20
ess/include/alibabacloud/ess/model/DescribeLimitationResult.h
View File

@@ -37,34 +37,38 @@ namespace AlibabaCloud
DescribeLimitationResult();
explicit DescribeLimitationResult(const std::string &payload);
~DescribeLimitationResult();
int getMaxNumberOfLifecycleHooks()const;
int getMaxNumberOfScalingRules()const;
int getMaxNumberOfScalingInstances()const;
int getMaxNumberOfScheduledTasks()const;
int getMaxNumberOfVServerGroups()const;
int getMaxNumberOfLoadBalancers()const;
int getMaxNumberOfAlbServerGroup()const;
int getMaxNumberOfMinSize()const;
int getMaxNumberOfScalingGroups()const;
int getMaxNumberOfNotificationConfigurations()const;
int getMaxNumberOfScalingConfigurations()const;
int getMaxNumberOfDBInstances()const;
int getMaxNumberOfMaxSize()const;
int getMaxNumberOfDBInstances()const;
int getMaxNumberOfLifecycleHooks()const;
int getMaxNumberOfScalingRules()const;
int getMaxNumberOfNlbServerGroup()const;
int getMaxNumberOfScalingConfigurations()const;
protected:
void parse(const std::string &payload);
private:
int maxNumberOfLifecycleHooks_;
int maxNumberOfScalingRules_;
int maxNumberOfScalingInstances_;
int maxNumberOfScheduledTasks_;
int maxNumberOfVServerGroups_;
int maxNumberOfLoadBalancers_;
int maxNumberOfAlbServerGroup_;
int maxNumberOfMinSize_;
int maxNumberOfScalingGroups_;
int maxNumberOfNotificationConfigurations_;
int maxNumberOfScalingConfigurations_;
int maxNumberOfDBInstances_;
int maxNumberOfMaxSize_;
int maxNumberOfDBInstances_;
int maxNumberOfLifecycleHooks_;
int maxNumberOfScalingRules_;
int maxNumberOfNlbServerGroup_;
int maxNumberOfScalingConfigurations_;
};
}

41
ess/include/alibabacloud/ess/model/DescribeNotificationConfigurationsRequest.h
View File

@@ -17,41 +17,38 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONCONFIGURATIONSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONCONFIGURATIONSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeNotificationConfigurationsRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeNotificationConfigurationsRequest : public RpcServiceRequest {
public:
DescribeNotificationConfigurationsRequest();
~DescribeNotificationConfigurationsRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
std::string resourceOwnerAccount_;
std::string scalingGroupId_;
long ownerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONCONFIGURATIONSREQUEST_H_

1
ess/include/alibabacloud/ess/model/DescribeNotificationConfigurationsResult.h
View File

@@ -34,6 +34,7 @@ namespace AlibabaCloud
public:
struct NotificationConfigurationModel
{
std::string timeZone;
std::string notificationArn;
std::string scalingGroupId;
std::vector<std::string> notificationTypes;

26
ess/include/alibabacloud/ess/model/DescribeNotificationTypesRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONTYPESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONTYPESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeNotificationTypesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeNotificationTypesRequest : public RpcServiceRequest {
public:
DescribeNotificationTypesRequest();
~DescribeNotificationTypesRequest();
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
@@ -46,9 +41,8 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONTYPESREQUEST_H_

132
ess/include/alibabacloud/ess/model/DescribePatternTypesRequest.h Normal file
View File

@@ -0,0 +1,132 @@
/*
* 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_ESS_MODEL_DESCRIBEPATTERNTYPESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEPATTERNTYPESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribePatternTypesRequest : public RpcServiceRequest {
public:
DescribePatternTypesRequest();
~DescribePatternTypesRequest();
int getMaximumCpuCoreCount() const;
void setMaximumCpuCoreCount(int maximumCpuCoreCount);
int getMaximumGpuAmount() const;
void setMaximumGpuAmount(int maximumGpuAmount);
float getMaximumMemorySize() const;
void setMaximumMemorySize(float maximumMemorySize);
int getMinimumCpuCoreCount() const;
void setMinimumCpuCoreCount(int minimumCpuCoreCount);
int getCores() const;
void setCores(int cores);
std::vector<std::string> getInstanceTypeFamilies() const;
void setInstanceTypeFamilies(const std::vector<std::string> &instanceTypeFamilies);
int getMinimumBaselineCredit() const;
void setMinimumBaselineCredit(int minimumBaselineCredit);
std::vector<std::string> getCpuArchitectures() const;
void setCpuArchitectures(const std::vector<std::string> &cpuArchitectures);
std::vector<std::string> getInstanceCategories() const;
void setInstanceCategories(const std::vector<std::string> &instanceCategories);
float getMaxPrice() const;
void setMaxPrice(float maxPrice);
int getMinimumGpuAmount() const;
void setMinimumGpuAmount(int minimumGpuAmount);
std::string getBurstablePerformance() const;
void setBurstablePerformance(const std::string &burstablePerformance);
std::vector<std::string> getPhysicalProcessorModels() const;
void setPhysicalProcessorModels(const std::vector<std::string> &physicalProcessorModels);
std::string getSpotStrategy() const;
void setSpotStrategy(const std::string &spotStrategy);
std::vector<std::string> getVSwitchId() const;
void setVSwitchId(const std::vector<std::string> &vSwitchId);
int getMinimumEniQuantity() const;
void setMinimumEniQuantity(int minimumEniQuantity);
float getMinimumMemorySize() const;
void setMinimumMemorySize(float minimumMemorySize);
std::string getInstanceFamilyLevel() const;
void setInstanceFamilyLevel(const std::string &instanceFamilyLevel);
std::vector<std::string> getZoneId() const;
void setZoneId(const std::vector<std::string> &zoneId);
std::vector<float> getMemoryList() const;
void setMemoryList(const std::vector<float> &memoryList);
float getMemory() const;
void setMemory(float memory);
int getMinimumEniIpv6AddressQuantity() const;
void setMinimumEniIpv6AddressQuantity(int minimumEniIpv6AddressQuantity);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::vector<int> getCoresList() const;
void setCoresList(const std::vector<int> &coresList);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<std::string> getArchitecture() const;
void setArchitecture(const std::vector<std::string> &architecture);
int getMinimumInitialCredit() const;
void setMinimumInitialCredit(int minimumInitialCredit);
std::vector<std::string> getExcludedInstanceType() const;
void setExcludedInstanceType(const std::vector<std::string> &excludedInstanceType);
int getMinimumEniPrivateIpAddressQuantity() const;
void setMinimumEniPrivateIpAddressQuantity(int minimumEniPrivateIpAddressQuantity);
std::vector<std::string> getGpuSpecs() const;
void setGpuSpecs(const std::vector<std::string> &gpuSpecs);
long getChannelId() const;
void setChannelId(long channelId);
private:
int maximumCpuCoreCount_;
int maximumGpuAmount_;
float maximumMemorySize_;
int minimumCpuCoreCount_;
int cores_;
std::vector<std::string> instanceTypeFamilies_;
int minimumBaselineCredit_;
std::vector<std::string> cpuArchitectures_;
std::vector<std::string> instanceCategories_;
float maxPrice_;
int minimumGpuAmount_;
std::string burstablePerformance_;
std::vector<std::string> physicalProcessorModels_;
std::string spotStrategy_;
std::vector<std::string> vSwitchId_;
int minimumEniQuantity_;
float minimumMemorySize_;
std::string instanceFamilyLevel_;
std::vector<std::string> zoneId_;
std::vector<float> memoryList_;
float memory_;
int minimumEniIpv6AddressQuantity_;
std::string accessKeyId_;
std::vector<int> coresList_;
std::string regionId_;
std::vector<std::string> architecture_;
int minimumInitialCredit_;
std::vector<std::string> excludedInstanceType_;
int minimumEniPrivateIpAddressQuantity_;
std::vector<std::string> gpuSpecs_;
long channelId_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEPATTERNTYPESREQUEST_H_

59
ess/include/alibabacloud/ess/model/DescribePatternTypesResult.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_ESS_MODEL_DESCRIBEPATTERNTYPESRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEPATTERNTYPESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribePatternTypesResult : public ServiceResult
{
public:
struct PatternType
{
int cores;
std::string instanceTypeFamily;
float memory;
std::string instanceFamilyLevel;
std::string instanceType;
};
DescribePatternTypesResult();
explicit DescribePatternTypesResult(const std::string &payload);
~DescribePatternTypesResult();
std::vector<PatternType> getPatternTypes()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PatternType> patternTypes_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEPATTERNTYPESRESULT_H_

26
ess/include/alibabacloud/ess/model/DescribeRegionsRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount() const;
@@ -52,9 +47,8 @@ namespace AlibabaCloud
long ownerId_;
std::string accessKeyId_;
std::string acceptLanguage_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSREQUEST_H_

92
ess/include/alibabacloud/ess/model/DescribeScalingActivitiesRequest.h
View File

@@ -17,46 +17,25 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivitiesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivitiesRequest : public RpcServiceRequest {
public:
DescribeScalingActivitiesRequest();
~DescribeScalingActivitiesRequest();
std::string getScalingActivityId9()const;
void setScalingActivityId9(const std::string& scalingActivityId9);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScalingActivityId5()const;
void setScalingActivityId5(const std::string& scalingActivityId5);
std::string getScalingActivityId6()const;
void setScalingActivityId6(const std::string& scalingActivityId6);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getScalingActivityId7()const;
void setScalingActivityId7(const std::string& scalingActivityId7);
std::string getScalingActivityId8()const;
void setScalingActivityId8(const std::string& scalingActivityId8);
std::string getScalingActivityId1()const;
void setScalingActivityId1(const std::string& scalingActivityId1);
std::string getScalingActivityId2()const;
void setScalingActivityId2(const std::string& scalingActivityId2);
std::string getScalingActivityId3()const;
void setScalingActivityId3(const std::string& scalingActivityId3);
std::string getScalingActivityId4()const;
void setScalingActivityId4(const std::string& scalingActivityId4);
std::string getInstanceRefreshTaskId() const;
void setInstanceRefreshTaskId(const std::string &instanceRefreshTaskId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
@@ -67,69 +46,30 @@ namespace AlibabaCloud
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getScalingActivityId11()const;
void setScalingActivityId11(const std::string& scalingActivityId11);
std::string getScalingActivityId10()const;
void setScalingActivityId10(const std::string& scalingActivityId10);
std::string getScalingActivityId13()const;
void setScalingActivityId13(const std::string& scalingActivityId13);
std::string getScalingActivityId12()const;
void setScalingActivityId12(const std::string& scalingActivityId12);
std::string getScalingActivityId15()const;
void setScalingActivityId15(const std::string& scalingActivityId15);
std::string getScalingActivityId14()const;
void setScalingActivityId14(const std::string& scalingActivityId14);
std::string getScalingActivityId17()const;
void setScalingActivityId17(const std::string& scalingActivityId17);
std::string getScalingActivityId16()const;
void setScalingActivityId16(const std::string& scalingActivityId16);
std::string getScalingActivityId19()const;
void setScalingActivityId19(const std::string& scalingActivityId19);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getScalingActivityId18()const;
void setScalingActivityId18(const std::string& scalingActivityId18);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingActivityId20()const;
void setScalingActivityId20(const std::string& scalingActivityId20);
std::vector<std::string> getScalingActivityId() const;
void setScalingActivityId(const std::vector<std::string> &scalingActivityId);
private:
std::string scalingActivityId9_;
long resourceOwnerId_;
std::string scalingActivityId5_;
std::string scalingActivityId6_;
std::string scalingGroupId_;
std::string scalingActivityId7_;
std::string scalingActivityId8_;
std::string scalingActivityId1_;
std::string scalingActivityId2_;
std::string scalingActivityId3_;
std::string scalingActivityId4_;
std::string instanceRefreshTaskId_;
int pageNumber_;
std::string accessKeyId_;
std::string statusCode_;
std::string regionId_;
int pageSize_;
std::string scalingActivityId11_;
std::string scalingActivityId10_;
std::string scalingActivityId13_;
std::string scalingActivityId12_;
std::string scalingActivityId15_;
std::string scalingActivityId14_;
std::string scalingActivityId17_;
std::string scalingActivityId16_;
std::string scalingActivityId19_;
std::string resourceOwnerAccount_;
std::string scalingActivityId18_;
std::string ownerAccount_;
long ownerId_;
std::string scalingActivityId20_;
std::vector<std::string> scalingActivityId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESREQUEST_H_

39
ess/include/alibabacloud/ess/model/DescribeScalingActivitiesResult.h
View File

@@ -34,19 +34,48 @@ namespace AlibabaCloud
public:
struct ScalingActivity
{
struct LifecycleHookContext
{
std::vector<std::string> ignoredLifecycleHookIds;
bool disableLifecycleHook;
};
struct ErrorMessagesItem
{
std::string description;
std::string message;
std::vector<std::string> failedInstanceIds;
std::string code;
};
int scalingInstanceNumber;
int progress;
std::string description;
std::string endTime;
std::string triggerSourceType;
std::string activityMetadata;
std::string autoCreatedCapacity;
std::string statusCode;
LifecycleHookContext lifecycleHookContext;
std::vector<std::string> stoppedInstances;
std::string cause;
std::string totalCapacity;
std::vector<std::string> destroyedInstances;
std::string instanceRefreshTaskId;
int progress;
std::string attachedCapacity;
std::string scalingActivityId;
std::string scalingGroupId;
std::string startTime;
std::string statusCode;
std::string autoCreatedCapacity;
int destroyedCapacity;
std::string triggerSourceId;
std::vector<std::string> startedInstances;
std::string statusMessage;
std::string cause;
std::string totalCapacity;
std::vector<ScalingActivity::ErrorMessagesItem> errorMessages;
int startedCapacity;
int createdCapacity;
std::vector<std::string> createdInstances;
int stoppedCapacity;
std::string errorCode;
std::string errorMessage;
std::string detail;
};

26
ess/include/alibabacloud/ess/model/DescribeScalingActivityDetailRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivityDetailRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivityDetailRequest : public RpcServiceRequest {
public:
DescribeScalingActivityDetailRequest();
~DescribeScalingActivityDetailRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount() const;
@@ -52,9 +47,8 @@ namespace AlibabaCloud
long ownerId_;
std::string scalingActivityId_;
std::string accessKeyId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILREQUEST_H_

92
ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsRequest.h
View File

@@ -17,116 +17,56 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScalingConfigurationsRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScalingConfigurationsRequest : public RpcServiceRequest {
public:
DescribeScalingConfigurationsRequest();
~DescribeScalingConfigurationsRequest();
std::string getScalingConfigurationId6()const;
void setScalingConfigurationId6(const std::string& scalingConfigurationId6);
std::string getScalingConfigurationId7()const;
void setScalingConfigurationId7(const std::string& scalingConfigurationId7);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScalingConfigurationId4()const;
void setScalingConfigurationId4(const std::string& scalingConfigurationId4);
std::string getScalingConfigurationId5()const;
void setScalingConfigurationId5(const std::string& scalingConfigurationId5);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getScalingConfigurationId8()const;
void setScalingConfigurationId8(const std::string& scalingConfigurationId8);
std::string getScalingConfigurationId9()const;
void setScalingConfigurationId9(const std::string& scalingConfigurationId9);
std::string getScalingConfigurationId10()const;
void setScalingConfigurationId10(const std::string& scalingConfigurationId10);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getScalingConfigurationName2()const;
void setScalingConfigurationName2(const std::string& scalingConfigurationName2);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getScalingConfigurationName3()const;
void setScalingConfigurationName3(const std::string& scalingConfigurationName3);
std::string getScalingConfigurationName1()const;
void setScalingConfigurationName1(const std::string& scalingConfigurationName1);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getScalingConfigurationId2()const;
void setScalingConfigurationId2(const std::string& scalingConfigurationId2);
std::string getScalingConfigurationId3()const;
void setScalingConfigurationId3(const std::string& scalingConfigurationId3);
std::string getScalingConfigurationId1()const;
void setScalingConfigurationId1(const std::string& scalingConfigurationId1);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getScalingConfigurationName6()const;
void setScalingConfigurationName6(const std::string& scalingConfigurationName6);
std::string getScalingConfigurationName7()const;
void setScalingConfigurationName7(const std::string& scalingConfigurationName7);
std::string getScalingConfigurationName4()const;
void setScalingConfigurationName4(const std::string& scalingConfigurationName4);
std::string getScalingConfigurationName5()const;
void setScalingConfigurationName5(const std::string& scalingConfigurationName5);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationName8()const;
void setScalingConfigurationName8(const std::string& scalingConfigurationName8);
std::string getScalingConfigurationName9()const;
void setScalingConfigurationName9(const std::string& scalingConfigurationName9);
std::string getScalingConfigurationName10()const;
void setScalingConfigurationName10(const std::string& scalingConfigurationName10);
std::vector<std::string> getScalingConfigurationName() const;
void setScalingConfigurationName(const std::vector<std::string> &scalingConfigurationName);
std::vector<std::string> getScalingConfigurationId() const;
void setScalingConfigurationId(const std::vector<std::string> &scalingConfigurationId);
private:
std::string scalingConfigurationId6_;
std::string scalingConfigurationId7_;
long resourceOwnerId_;
std::string scalingConfigurationId4_;
std::string scalingConfigurationId5_;
std::string scalingGroupId_;
std::string scalingConfigurationId8_;
std::string scalingConfigurationId9_;
std::string scalingConfigurationId10_;
int pageNumber_;
std::string accessKeyId_;
std::string scalingConfigurationName2_;
std::string regionId_;
std::string scalingConfigurationName3_;
std::string scalingConfigurationName1_;
int pageSize_;
std::string scalingConfigurationId2_;
std::string scalingConfigurationId3_;
std::string scalingConfigurationId1_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string scalingConfigurationName6_;
std::string scalingConfigurationName7_;
std::string scalingConfigurationName4_;
std::string scalingConfigurationName5_;
long ownerId_;
std::string scalingConfigurationName8_;
std::string scalingConfigurationName9_;
std::string scalingConfigurationName10_;
std::vector<std::string> scalingConfigurationName_;
std::vector<std::string> scalingConfigurationId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSREQUEST_H_

85
ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h
View File

@@ -38,18 +38,31 @@ namespace AlibabaCloud
{
std::string managedPrivateSpaceId;
};
struct SecurityOptions
{
std::string confidentialComputingMode;
};
struct ResourcePoolOptions
{
std::string strategy;
std::vector<std::string> privatePoolIds;
};
struct DataDisk
{
std::string snapshotId;
bool burstingEnabled;
std::string description;
std::string category;
std::string kMSKeyId;
std::string description;
int size;
std::vector<std::string> categories;
std::string performanceLevel;
std::string device;
int size;
std::string encrypted;
bool deleteWithInstance;
std::string autoSnapshotPolicyId;
std::string diskName;
long provisionedIops;
std::string snapshotId;
};
struct Tag
{
@@ -61,38 +74,96 @@ namespace AlibabaCloud
float priceLimit;
std::string instanceType;
};
struct InstancePatternInfo
{
float memory;
std::vector<std::string> physicalProcessorModels;
int minimumEniQuantity;
std::vector<std::string> excludedInstanceTypes;
int minimumBaselineCredit;
float maximumMemorySize;
int cores;
int minimumCpuCoreCount;
std::vector<std::string> cpuArchitectures;
int maximumCpuCoreCount;
int minimumEniPrivateIpAddressQuantity;
std::vector<std::string> gpuSpecs;
std::vector<std::string> instanceCategories;
std::string instanceFamilyLevel;
int maximumGpuAmount;
float minimumMemorySize;
int minimumEniIpv6AddressQuantity;
int minimumGpuAmount;
float maxPrice;
std::string burstablePerformance;
std::vector<std::string> instanceTypeFamilies;
int minimumInitialCredit;
std::vector<std::string> architectures;
};
struct CustomPriority
{
std::string instanceType;
std::string vswitchId;
};
struct NetworkInterface
{
std::string networkInterfaceTrafficMode;
std::vector<std::string> securityGroupIds1;
int ipv6AddressCount;
std::string instanceType;
};
std::string scalingConfigurationName;
std::string dedicatedHostId;
std::vector<std::string> weightedCapacities;
std::vector<ScalingConfiguration::DataDisk> dataDisks;
std::string resourceGroupId;
std::string systemDiskDescription;
bool imageOptionsLoginAsNonRoot;
int memory;
long systemDiskProvisionedIops;
int cpu;
std::string systemDiskEncryptAlgorithm;
std::string ramRoleName;
std::string systemDiskPerformanceLevel;
std::string imageId;
std::string storageSetId;
std::vector<ScalingConfiguration::Tag> tags;
std::string hostName;
int loadBalancerWeight;
std::string scalingGroupId;
std::string systemDiskKMSKeyId;
std::string imageFamily;
std::string privatePoolOptionsMatchCriteria;
bool deletionProtection;
std::string httpEndpoint;
std::vector<std::string> securityGroupIds;
std::string internetChargeType;
std::string privatePoolOptionsId;
std::string instanceName;
std::string internetChargeType;
std::string deploymentSetId;
std::string instanceName;
std::string spotInterruptionBehavior;
int internetMaxBandwidthOut;
std::vector<ScalingConfiguration::InstancePatternInfo> instancePatternInfos;
SecurityOptions securityOptions;
std::string creationTime;
std::string affinity;
std::string scalingConfigurationId;
std::string securityEnhancementStrategy;
std::string dedicatedHostClusterId;
std::string tenancy;
std::string imageOwnerAlias;
int systemDiskSize;
std::string userData;
int spotDuration;
std::string lifecycleState;
int storageSetPartitionNumber;
bool systemDiskEncrypted;
std::vector<ScalingConfiguration::CustomPriority> customPriorities;
std::string systemDiskAutoSnapshotPolicyId;
std::string systemDiskName;
int ipv6AddressCount;
std::vector<ScalingConfiguration::NetworkInterface> networkInterfaces;
std::vector<std::string> systemDiskCategories;
SchedulerOptions schedulerOptions;
std::vector<ScalingConfiguration::SpotPriceModel> spotPriceLimit;
std::vector<std::string> instanceTypes;
@@ -100,12 +171,16 @@ namespace AlibabaCloud
std::string spotStrategy;
bool passwordInherit;
std::string keyPairName;
ResourcePoolOptions resourcePoolOptions;
std::string ioOptimized;
std::string zoneId;
std::string hpcClusterId;
bool passwordSetted;
std::string securityGroupId;
std::string systemDiskCategory;
bool systemDiskBurstingEnabled;
std::string imageName;
std::string httpTokens;
int internetMaxBandwidthIn;
std::string instanceGeneration;
std::string instanceDescription;

99
ess/include/alibabacloud/ess/model/DescribeScalingGroupsRequest.h
View File

@@ -17,38 +17,35 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScalingGroupsRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScalingGroupsRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeScalingGroupsRequest();
~DescribeScalingGroupsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScalingGroupId10()const;
void setScalingGroupId10(const std::string& scalingGroupId10);
std::string getScalingGroupId12()const;
void setScalingGroupId12(const std::string& scalingGroupId12);
std::string getScalingGroupId13()const;
void setScalingGroupId13(const std::string& scalingGroupId13);
std::string getScalingGroupId14()const;
void setScalingGroupId14(const std::string& scalingGroupId14);
std::string getScalingGroupId15()const;
void setScalingGroupId15(const std::string& scalingGroupId15);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getGroupType() const;
void setGroupType(const std::string &groupType);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<std::string> getScalingGroupId() const;
void setScalingGroupId(const std::vector<std::string> &scalingGroupId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
@@ -61,8 +58,6 @@ namespace AlibabaCloud
void setScalingGroupName20(const std::string &scalingGroupName20);
std::string getScalingGroupName19() const;
void setScalingGroupName19(const std::string &scalingGroupName19);
std::string getScalingGroupId20()const;
void setScalingGroupId20(const std::string& scalingGroupId20);
std::string getScalingGroupName18() const;
void setScalingGroupName18(const std::string &scalingGroupName18);
std::string getScalingGroupName17() const;
@@ -79,54 +74,28 @@ namespace AlibabaCloud
void setScalingGroupName1(const std::string &scalingGroupName1);
std::string getScalingGroupName2() const;
void setScalingGroupName2(const std::string &scalingGroupName2);
std::string getScalingGroupId2()const;
void setScalingGroupId2(const std::string& scalingGroupId2);
std::string getScalingGroupId1()const;
void setScalingGroupId1(const std::string& scalingGroupId1);
std::string getScalingGroupId6()const;
void setScalingGroupId6(const std::string& scalingGroupId6);
std::string getScalingGroupId16()const;
void setScalingGroupId16(const std::string& scalingGroupId16);
std::string getScalingGroupName7() const;
void setScalingGroupName7(const std::string &scalingGroupName7);
std::string getScalingGroupName11() const;
void setScalingGroupName11(const std::string &scalingGroupName11);
std::string getScalingGroupId5()const;
void setScalingGroupId5(const std::string& scalingGroupId5);
std::string getScalingGroupId17()const;
void setScalingGroupId17(const std::string& scalingGroupId17);
std::string getScalingGroupName8() const;
void setScalingGroupName8(const std::string &scalingGroupName8);
std::string getScalingGroupName10() const;
void setScalingGroupName10(const std::string &scalingGroupName10);
std::string getScalingGroupId4()const;
void setScalingGroupId4(const std::string& scalingGroupId4);
std::string getScalingGroupId18()const;
void setScalingGroupId18(const std::string& scalingGroupId18);
std::string getScalingGroupName9() const;
void setScalingGroupName9(const std::string &scalingGroupName9);
std::string getScalingGroupId3()const;
void setScalingGroupId3(const std::string& scalingGroupId3);
std::string getScalingGroupId19()const;
void setScalingGroupId19(const std::string& scalingGroupId19);
std::string getScalingGroupName3() const;
void setScalingGroupName3(const std::string &scalingGroupName3);
std::string getScalingGroupName15() const;
void setScalingGroupName15(const std::string &scalingGroupName15);
std::string getScalingGroupId9()const;
void setScalingGroupId9(const std::string& scalingGroupId9);
std::string getScalingGroupName4() const;
void setScalingGroupName4(const std::string &scalingGroupName4);
std::string getScalingGroupName14() const;
void setScalingGroupName14(const std::string &scalingGroupName14);
std::string getScalingGroupId8()const;
void setScalingGroupId8(const std::string& scalingGroupId8);
std::string getScalingGroupName5() const;
void setScalingGroupName5(const std::string &scalingGroupName5);
std::string getScalingGroupName13() const;
void setScalingGroupName13(const std::string &scalingGroupName13);
std::string getScalingGroupId7()const;
void setScalingGroupId7(const std::string& scalingGroupId7);
std::string getScalingGroupName6() const;
void setScalingGroupName6(const std::string &scalingGroupName6);
std::string getScalingGroupName12() const;
@@ -134,19 +103,17 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string scalingGroupId10_;
std::string scalingGroupId12_;
std::string scalingGroupId13_;
std::string scalingGroupId14_;
std::string scalingGroupId15_;
std::string resourceGroupId_;
std::string groupType_;
std::vector<Tag> tag_;
long ownerId_;
std::vector<std::string> scalingGroupId_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string scalingGroupName20_;
std::string scalingGroupName19_;
std::string scalingGroupId20_;
std::string scalingGroupName18_;
std::string scalingGroupName17_;
std::string scalingGroupName16_;
@@ -155,35 +122,21 @@ namespace AlibabaCloud
std::string ownerAccount_;
std::string scalingGroupName1_;
std::string scalingGroupName2_;
std::string scalingGroupId2_;
std::string scalingGroupId1_;
std::string scalingGroupId6_;
std::string scalingGroupId16_;
std::string scalingGroupName7_;
std::string scalingGroupName11_;
std::string scalingGroupId5_;
std::string scalingGroupId17_;
std::string scalingGroupName8_;
std::string scalingGroupName10_;
std::string scalingGroupId4_;
std::string scalingGroupId18_;
std::string scalingGroupName9_;
std::string scalingGroupId3_;
std::string scalingGroupId19_;
std::string scalingGroupName3_;
std::string scalingGroupName15_;
std::string scalingGroupId9_;
std::string scalingGroupName4_;
std::string scalingGroupName14_;
std::string scalingGroupId8_;
std::string scalingGroupName5_;
std::string scalingGroupName13_;
std::string scalingGroupId7_;
std::string scalingGroupName6_;
std::string scalingGroupName12_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSREQUEST_H_

107
ess/include/alibabacloud/ess/model/DescribeScalingGroupsResult.h
View File

@@ -34,6 +34,14 @@ namespace AlibabaCloud
public:
struct ScalingGroup
{
struct CapacityOptions
{
int onDemandBaseCapacity;
bool compensateWithOnDemand;
int onDemandPercentageAboveBaseCapacity;
bool spotAutoReplaceOnDemand;
std::string priceComparisonMode;
};
struct VServerGroup
{
struct VServerGroupAttribute
@@ -45,46 +53,107 @@ namespace AlibabaCloud
std::string loadBalancerId;
std::vector<VServerGroup::VServerGroupAttribute> vServerGroupAttributes;
};
struct LaunchTemplateOverride
{
int weightedCapacity;
float spotPriceLimit;
std::string instanceType;
};
struct AlbServerGroup
{
std::string albServerGroupId;
int port;
int weight;
};
struct ServerGroup
{
std::string type;
int port;
std::string serverGroupId;
int weight;
};
struct LoadBalancerConfig
{
std::string loadBalancerId;
int weight;
};
struct Tag
{
std::string tagKey;
bool propagate;
std::string tagValue;
};
struct DBInstance
{
std::string type;
std::string dBInstanceId;
std::vector<std::string> securityGroupIds;
};
bool spotInstanceRemedy;
std::string resourceGroupId;
std::vector<ScalingGroup::ServerGroup> serverGroups;
std::string activeScalingConfigurationId;
bool compensateWithOnDemand;
int onDemandPercentageAboveBaseCapacity;
int desiredCapacity;
std::string lifecycleState;
std::string modificationTime;
std::vector<ScalingGroup::AlbServerGroup> albServerGroups;
int onDemandBaseCapacity;
std::vector<std::string> removalPolicies;
int pendingWaitCapacity;
int totalCapacity;
int removingWaitCapacity;
int protectedCapacity;
int standbyCapacity;
std::string scalingPolicy;
std::vector<ScalingGroup::LaunchTemplateOverride> launchTemplateOverrides;
std::vector<ScalingGroup::Tag> tags;
std::vector<std::string> suspendedProcesses;
int removingCapacity;
std::vector<std::string> vSwitchIds;
int pendingCapacity;
std::string scalingGroupId;
int pendingCapacity;
std::string vSwitchId;
std::vector<std::string> loadBalancerIds;
int spotInstancePools;
bool groupDeletionProtection;
std::string launchTemplateId;
int maxSize;
std::string customPolicyARN;
std::vector<ScalingGroup::LoadBalancerConfig> loadBalancerConfigs;
int spotCapacity;
std::string scalingGroupName;
int activeCapacity;
int minSize;
int defaultCooldown;
bool scaleOutAmountCheck;
int defaultCooldown;
std::string vpcId;
std::string launchTemplateVersion;
std::string groupType;
std::string creationTime;
std::string launchTemplateVersion;
std::string multiAZPolicy;
int stoppedCapacity;
std::vector<ScalingGroup::VServerGroup> vServerGroups;
std::string regionId;
std::string currentHostName;
CapacityOptions capacityOptions;
std::vector<std::string> dBInstanceIds;
std::string healthCheckType;
bool compensateWithOnDemand;
int onDemandPercentageAboveBaseCapacity;
std::string modificationTime;
std::string lifecycleState;
int totalInstanceCount;
std::vector<std::string> healthCheckTypes;
std::string allocationStrategy;
bool weighted;
int initCapacity;
int pendingWaitCapacity;
int totalCapacity;
int removingWaitCapacity;
bool isElasticStrengthInAlarm;
std::string spotAllocationStrategy;
int protectedCapacity;
int standbyCapacity;
std::string scalingPolicy;
bool groupDeletionProtection;
int maxSize;
bool enableDesiredCapacity;
int minSize;
int activeCapacity;
bool azBalance;
bool systemSuspended;
std::string monitorGroupId;
std::vector<ScalingGroup::VServerGroup> vServerGroups;
std::string regionId;
std::vector<ScalingGroup::DBInstance> dBInstances;
int maxInstanceLifetime;
int stopInstanceTimeout;
};

122
ess/include/alibabacloud/ess/model/DescribeScalingInstancesRequest.h
View File

@@ -17,62 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScalingInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScalingInstancesRequest : public RpcServiceRequest {
public:
DescribeScalingInstancesRequest();
~DescribeScalingInstancesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getCreationType()const;
void setCreationType(const std::string& creationType);
std::string getInstanceId1()const;
void setInstanceId1(const std::string& instanceId1);
std::string getInstanceId3()const;
void setInstanceId3(const std::string& instanceId3);
std::string getInstanceId2()const;
void setInstanceId2(const std::string& instanceId2);
std::string getInstanceId5()const;
void setInstanceId5(const std::string& instanceId5);
std::string getInstanceId4()const;
void setInstanceId4(const std::string& instanceId4);
std::string getInstanceId7()const;
void setInstanceId7(const std::string& instanceId7);
std::string getInstanceId6()const;
void setInstanceId6(const std::string& instanceId6);
std::string getInstanceId9()const;
void setInstanceId9(const std::string& instanceId9);
std::string getInstanceId8()const;
void setInstanceId8(const std::string& instanceId8);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationId()const;
void setScalingConfigurationId(const std::string& scalingConfigurationId);
std::string getHealthStatus()const;
void setHealthStatus(const std::string& healthStatus);
std::string getInstanceId10()const;
void setInstanceId10(const std::string& instanceId10);
std::string getInstanceId12()const;
void setInstanceId12(const std::string& instanceId12);
std::string getInstanceId11()const;
void setInstanceId11(const std::string& instanceId11);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getLifecycleState() const;
void setLifecycleState(const std::string &lifecycleState);
std::string getCreationType() const;
void setCreationType(const std::string &creationType);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
@@ -81,64 +46,45 @@ namespace AlibabaCloud
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getInstanceId20()const;
void setInstanceId20(const std::string& instanceId20);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getInstanceId18()const;
void setInstanceId18(const std::string& instanceId18);
std::string getInstanceId17()const;
void setInstanceId17(const std::string& instanceId17);
std::string getInstanceId19()const;
void setInstanceId19(const std::string& instanceId19);
std::string getInstanceId14()const;
void setInstanceId14(const std::string& instanceId14);
std::string getInstanceId13()const;
void setInstanceId13(const std::string& instanceId13);
std::string getInstanceId16()const;
void setInstanceId16(const std::string& instanceId16);
std::string getInstanceId15()const;
void setInstanceId15(const std::string& instanceId15);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingActivityId() const;
void setScalingActivityId(const std::string &scalingActivityId);
std::vector<std::string> getCreationTypes() const;
void setCreationTypes(const std::vector<std::string> &creationTypes);
std::string getScalingConfigurationId() const;
void setScalingConfigurationId(const std::string &scalingConfigurationId);
std::vector<std::string> getInstanceId() const;
void setInstanceId(const std::vector<std::string> &instanceId);
std::string getHealthStatus() const;
void setHealthStatus(const std::string &healthStatus);
std::vector<std::string> getLifecycleStates() const;
void setLifecycleStates(const std::vector<std::string> &lifecycleStates);
private:
long resourceOwnerId_;
std::string creationType_;
std::string instanceId1_;
std::string instanceId3_;
std::string instanceId2_;
std::string instanceId5_;
std::string instanceId4_;
std::string instanceId7_;
std::string instanceId6_;
std::string instanceId9_;
std::string instanceId8_;
long ownerId_;
std::string scalingConfigurationId_;
std::string healthStatus_;
std::string instanceId10_;
std::string instanceId12_;
std::string instanceId11_;
std::string scalingGroupId_;
std::string lifecycleState_;
std::string creationType_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string instanceId20_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string instanceId18_;
std::string instanceId17_;
std::string instanceId19_;
std::string instanceId14_;
std::string instanceId13_;
std::string instanceId16_;
std::string instanceId15_;
long ownerId_;
std::string scalingActivityId_;
std::vector<std::string> creationTypes_;
std::string scalingConfigurationId_;
std::vector<std::string> instanceId_;
std::string healthStatus_;
std::vector<std::string> lifecycleStates_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESREQUEST_H_

11
ess/include/alibabacloud/ess/model/DescribeScalingInstancesResult.h
View File

@@ -36,17 +36,24 @@ namespace AlibabaCloud
{
int loadBalancerWeight;
std::string createdTime;
std::string privateIpAddress;
std::string zoneId;
std::string instanceId;
std::string scalingActivityId;
std::string scalingGroupId;
std::string healthStatus;
std::string lifecycleState;
std::string launchTemplateId;
std::string lifecycleState;
std::string scalingInstanceId;
std::string creationType;
int weightedCapacity;
std::string warmupState;
std::string creationTime;
std::string launchTemplateVersion;
bool entrusted;
std::string scalingConfigurationId;
std::string instanceType;
std::string spotStrategy;
};
@@ -57,6 +64,7 @@ namespace AlibabaCloud
int getPageSize()const;
int getPageNumber()const;
std::vector<ScalingInstance> getScalingInstances()const;
int getTotalSpotCount()const;
protected:
void parse(const std::string &payload);
@@ -65,6 +73,7 @@ namespace AlibabaCloud
int pageSize_;
int pageNumber_;
std::vector<ScalingInstance> scalingInstances_;
int totalSpotCount_;
};
}

137
ess/include/alibabacloud/ess/model/DescribeScalingRulesRequest.h
View File

@@ -17,74 +17,31 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScalingRulesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScalingRulesRequest : public RpcServiceRequest {
public:
DescribeScalingRulesRequest();
~DescribeScalingRulesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScalingRuleId10()const;
void setScalingRuleId10(const std::string& scalingRuleId10);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getScalingRuleAri1()const;
void setScalingRuleAri1(const std::string& scalingRuleAri1);
std::string getScalingRuleAri2()const;
void setScalingRuleAri2(const std::string& scalingRuleAri2);
std::string getScalingRuleAri3()const;
void setScalingRuleAri3(const std::string& scalingRuleAri3);
std::string getScalingRuleAri4()const;
void setScalingRuleAri4(const std::string& scalingRuleAri4);
std::string getScalingRuleAri5()const;
void setScalingRuleAri5(const std::string& scalingRuleAri5);
std::string getScalingRuleAri6()const;
void setScalingRuleAri6(const std::string& scalingRuleAri6);
std::string getScalingRuleAri7()const;
void setScalingRuleAri7(const std::string& scalingRuleAri7);
std::string getScalingRuleAri8()const;
void setScalingRuleAri8(const std::string& scalingRuleAri8);
bool getShowAlarmRules()const;
void setShowAlarmRules(bool showAlarmRules);
std::string getScalingRuleName1()const;
void setScalingRuleName1(const std::string& scalingRuleName1);
std::string getScalingRuleName2()const;
void setScalingRuleName2(const std::string& scalingRuleName2);
std::string getScalingRuleName3()const;
void setScalingRuleName3(const std::string& scalingRuleName3);
std::string getScalingRuleName4()const;
void setScalingRuleName4(const std::string& scalingRuleName4);
std::string getScalingRuleName5()const;
void setScalingRuleName5(const std::string& scalingRuleName5);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getScalingRuleName6()const;
void setScalingRuleName6(const std::string& scalingRuleName6);
std::string getScalingRuleName7()const;
void setScalingRuleName7(const std::string& scalingRuleName7);
std::string getScalingRuleName8()const;
void setScalingRuleName8(const std::string& scalingRuleName8);
std::string getScalingRuleAri9()const;
void setScalingRuleAri9(const std::string& scalingRuleAri9);
std::string getScalingRuleName9()const;
void setScalingRuleName9(const std::string& scalingRuleName9);
std::vector<std::string> getScalingRuleId() const;
void setScalingRuleId(const std::vector<std::string> &scalingRuleId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::vector<std::string> getScalingRuleName() const;
void setScalingRuleName(const std::vector<std::string> &scalingRuleName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
@@ -95,74 +52,30 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getScalingRuleName10()const;
void setScalingRuleName10(const std::string& scalingRuleName10);
std::string getScalingRuleId8()const;
void setScalingRuleId8(const std::string& scalingRuleId8);
std::string getScalingRuleId9()const;
void setScalingRuleId9(const std::string& scalingRuleId9);
std::string getScalingRuleAri10()const;
void setScalingRuleAri10(const std::string& scalingRuleAri10);
std::string getScalingRuleId4()const;
void setScalingRuleId4(const std::string& scalingRuleId4);
std::string getScalingRuleId5()const;
void setScalingRuleId5(const std::string& scalingRuleId5);
std::string getScalingRuleId6()const;
void setScalingRuleId6(const std::string& scalingRuleId6);
std::string getScalingRuleId7()const;
void setScalingRuleId7(const std::string& scalingRuleId7);
std::string getScalingRuleId1()const;
void setScalingRuleId1(const std::string& scalingRuleId1);
std::string getScalingRuleId2()const;
void setScalingRuleId2(const std::string& scalingRuleId2);
std::string getScalingRuleId3()const;
void setScalingRuleId3(const std::string& scalingRuleId3);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<std::string> getScalingRuleAri() const;
void setScalingRuleAri(const std::vector<std::string> &scalingRuleAri);
bool getShowAlarmRules() const;
void setShowAlarmRules(bool showAlarmRules);
private:
long resourceOwnerId_;
std::string scalingRuleId10_;
long ownerId_;
std::string scalingRuleAri1_;
std::string scalingRuleAri2_;
std::string scalingRuleAri3_;
std::string scalingRuleAri4_;
std::string scalingRuleAri5_;
std::string scalingRuleAri6_;
std::string scalingRuleAri7_;
std::string scalingRuleAri8_;
bool showAlarmRules_;
std::string scalingRuleName1_;
std::string scalingRuleName2_;
std::string scalingRuleName3_;
std::string scalingRuleName4_;
std::string scalingRuleName5_;
std::string scalingGroupId_;
std::string scalingRuleName6_;
std::string scalingRuleName7_;
std::string scalingRuleName8_;
std::string scalingRuleAri9_;
std::string scalingRuleName9_;
std::vector<std::string> scalingRuleId_;
int pageNumber_;
std::string accessKeyId_;
std::vector<std::string> scalingRuleName_;
std::string regionId_;
int pageSize_;
std::string scalingRuleType_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string scalingRuleName10_;
std::string scalingRuleId8_;
std::string scalingRuleId9_;
std::string scalingRuleAri10_;
std::string scalingRuleId4_;
std::string scalingRuleId5_;
std::string scalingRuleId6_;
std::string scalingRuleId7_;
std::string scalingRuleId1_;
std::string scalingRuleId2_;
std::string scalingRuleId3_;
long ownerId_;
std::vector<std::string> scalingRuleAri_;
bool showAlarmRules_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESREQUEST_H_

47
ess/include/alibabacloud/ess/model/DescribeScalingRulesResult.h
View File

@@ -43,6 +43,7 @@ namespace AlibabaCloud
};
std::string metricName;
std::string comparisonOperator;
std::string metricType;
std::vector<Alarm::Dimension> dimensions;
int evaluationCount;
std::string alarmTaskName;
@@ -56,30 +57,52 @@ namespace AlibabaCloud
float metricIntervalLowerBound;
int scalingAdjustment;
};
float targetValue;
struct AlarmDimension
{
std::string dimensionValue;
std::string dimensionKey;
};
struct HybridMetric
{
struct Dimension2
{
std::string dimensionValue;
std::string dimensionKey;
};
std::string metricName;
std::string statistic;
std::string expression;
std::vector<HybridMetric::Dimension2> dimensions1;
std::string id;
};
std::vector<ScalingRule::StepAdjustment> stepAdjustments;
std::string scalingGroupId;
int cooldown;
std::string predictiveValueBehavior;
std::string metricType;
std::vector<ScalingRule::HybridMetric> hybridMetrics;
std::string scalingRuleAri;
std::string metricName;
std::string scalingRuleName;
int scaleOutEvaluationCount;
int initialMaxSize;
std::string scalingRuleType;
int estimatedInstanceWarmup;
int predictiveTaskBufferTime;
int predictiveValueBuffer;
float targetValue;
std::string scalingGroupId;
std::vector<ScalingRule::Alarm> alarms;
std::string scalingRuleId;
int minAdjustmentMagnitude;
bool disableScaleIn;
int maxSize;
std::string adjustmentType;
std::string scalingRuleAri;
int minSize;
std::string metricName;
std::string scalingRuleName;
std::vector<ScalingRule::AlarmDimension> alarmDimensions;
int adjustmentValue;
int scaleOutEvaluationCount;
int initialMaxSize;
std::string scalingRuleType;
int estimatedInstanceWarmup;
int scaleInEvaluationCount;
std::string hybridMonitorNamespace;
std::string predictiveScalingMode;
int predictiveValueBuffer;
int predictiveTaskBufferTime;
int scaleInEvaluationCount;
};

233
ess/include/alibabacloud/ess/model/DescribeScheduledTasksRequest.h
View File

@@ -17,236 +17,71 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCHEDULEDTASKSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCHEDULEDTASKSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DescribeScheduledTasksRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DescribeScheduledTasksRequest : public RpcServiceRequest {
public:
DescribeScheduledTasksRequest();
~DescribeScheduledTasksRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScheduledAction2()const;
void setScheduledAction2(const std::string& scheduledAction2);
std::string getScheduledAction1()const;
void setScheduledAction1(const std::string& scheduledAction1);
std::string getScheduledAction6()const;
void setScheduledAction6(const std::string& scheduledAction6);
std::string getScheduledAction5()const;
void setScheduledAction5(const std::string& scheduledAction5);
std::string getScheduledAction4()const;
void setScheduledAction4(const std::string& scheduledAction4);
std::string getScheduledAction3()const;
void setScheduledAction3(const std::string& scheduledAction3);
std::string getScheduledAction9()const;
void setScheduledAction9(const std::string& scheduledAction9);
std::string getScheduledAction8()const;
void setScheduledAction8(const std::string& scheduledAction8);
std::string getScheduledAction7()const;
void setScheduledAction7(const std::string& scheduledAction7);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getScheduledTaskName20()const;
void setScheduledTaskName20(const std::string& scheduledTaskName20);
std::string getScheduledTaskName19()const;
void setScheduledTaskName19(const std::string& scheduledTaskName19);
std::string getScheduledTaskName18()const;
void setScheduledTaskName18(const std::string& scheduledTaskName18);
std::string getScheduledTaskId20()const;
void setScheduledTaskId20(const std::string& scheduledTaskId20);
std::vector<std::string> getScheduledAction() const;
void setScheduledAction(const std::vector<std::string> &scheduledAction);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getScheduledTaskName13()const;
void setScheduledTaskName13(const std::string& scheduledTaskName13);
std::string getScheduledTaskName12()const;
void setScheduledTaskName12(const std::string& scheduledTaskName12);
std::string getScheduledTaskName11()const;
void setScheduledTaskName11(const std::string& scheduledTaskName11);
std::string getScheduledTaskName10()const;
void setScheduledTaskName10(const std::string& scheduledTaskName10);
std::string getScheduledTaskName17()const;
void setScheduledTaskName17(const std::string& scheduledTaskName17);
std::string getScheduledTaskName16()const;
void setScheduledTaskName16(const std::string& scheduledTaskName16);
std::string getTaskName() const;
void setTaskName(const std::string &taskName);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getScheduledTaskName15()const;
void setScheduledTaskName15(const std::string& scheduledTaskName15);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getScheduledTaskName14()const;
void setScheduledTaskName14(const std::string& scheduledTaskName14);
std::string getScheduledTaskId2()const;
void setScheduledTaskId2(const std::string& scheduledTaskId2);
std::string getScheduledTaskId1()const;
void setScheduledTaskId1(const std::string& scheduledTaskId1);
std::string getScheduledTaskId4()const;
void setScheduledTaskId4(const std::string& scheduledTaskId4);
std::string getScheduledTaskId18()const;
void setScheduledTaskId18(const std::string& scheduledTaskId18);
std::string getScheduledTaskId3()const;
void setScheduledTaskId3(const std::string& scheduledTaskId3);
std::string getScheduledTaskId19()const;
void setScheduledTaskId19(const std::string& scheduledTaskId19);
std::string getScheduledTaskId6()const;
void setScheduledTaskId6(const std::string& scheduledTaskId6);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getScheduledTaskId5()const;
void setScheduledTaskId5(const std::string& scheduledTaskId5);
std::string getScheduledTaskId8()const;
void setScheduledTaskId8(const std::string& scheduledTaskId8);
std::string getScheduledTaskName9()const;
void setScheduledTaskName9(const std::string& scheduledTaskName9);
std::string getScheduledAction20()const;
void setScheduledAction20(const std::string& scheduledAction20);
std::string getScheduledTaskId7()const;
void setScheduledTaskId7(const std::string& scheduledTaskId7);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getScheduledTaskId12()const;
void setScheduledTaskId12(const std::string& scheduledTaskId12);
std::string getScheduledTaskName7()const;
void setScheduledTaskName7(const std::string& scheduledTaskName7);
std::string getScheduledTaskId9()const;
void setScheduledTaskId9(const std::string& scheduledTaskId9);
std::string getScheduledTaskId13()const;
void setScheduledTaskId13(const std::string& scheduledTaskId13);
std::string getScheduledTaskName8()const;
void setScheduledTaskName8(const std::string& scheduledTaskName8);
std::string getScheduledTaskId10()const;
void setScheduledTaskId10(const std::string& scheduledTaskId10);
std::string getScheduledTaskName5()const;
void setScheduledTaskName5(const std::string& scheduledTaskName5);
std::string getScheduledTaskId11()const;
void setScheduledTaskId11(const std::string& scheduledTaskId11);
std::string getScheduledTaskName6()const;
void setScheduledTaskName6(const std::string& scheduledTaskName6);
std::string getScheduledTaskId16()const;
void setScheduledTaskId16(const std::string& scheduledTaskId16);
std::string getScheduledTaskName3()const;
void setScheduledTaskName3(const std::string& scheduledTaskName3);
std::string getScheduledTaskId17()const;
void setScheduledTaskId17(const std::string& scheduledTaskId17);
std::string getScheduledTaskName4()const;
void setScheduledTaskName4(const std::string& scheduledTaskName4);
std::string getScheduledTaskId14()const;
void setScheduledTaskId14(const std::string& scheduledTaskId14);
std::string getScheduledTaskName1()const;
void setScheduledTaskName1(const std::string& scheduledTaskName1);
std::string getScheduledTaskId15()const;
void setScheduledTaskId15(const std::string& scheduledTaskId15);
std::string getScheduledTaskName2()const;
void setScheduledTaskName2(const std::string& scheduledTaskName2);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getScheduledAction18()const;
void setScheduledAction18(const std::string& scheduledAction18);
std::string getScheduledAction19()const;
void setScheduledAction19(const std::string& scheduledAction19);
std::string getScheduledAction16()const;
void setScheduledAction16(const std::string& scheduledAction16);
std::string getScheduledAction17()const;
void setScheduledAction17(const std::string& scheduledAction17);
std::string getScheduledAction14()const;
void setScheduledAction14(const std::string& scheduledAction14);
std::string getScheduledAction15()const;
void setScheduledAction15(const std::string& scheduledAction15);
std::string getScheduledAction12()const;
void setScheduledAction12(const std::string& scheduledAction12);
std::string getScheduledAction13()const;
void setScheduledAction13(const std::string& scheduledAction13);
std::string getScheduledAction10()const;
void setScheduledAction10(const std::string& scheduledAction10);
std::string getScheduledAction11()const;
void setScheduledAction11(const std::string& scheduledAction11);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getRecurrenceValue() const;
void setRecurrenceValue(const std::string &recurrenceValue);
std::vector<std::string> getScheduledTaskName() const;
void setScheduledTaskName(const std::vector<std::string> &scheduledTaskName);
bool getTaskEnabled() const;
void setTaskEnabled(bool taskEnabled);
std::vector<std::string> getScheduledTaskId() const;
void setScheduledTaskId(const std::vector<std::string> &scheduledTaskId);
std::string getRecurrenceType() const;
void setRecurrenceType(const std::string &recurrenceType);
private:
long resourceOwnerId_;
std::string scheduledAction2_;
std::string scheduledAction1_;
std::string scheduledAction6_;
std::string scheduledAction5_;
std::string scheduledAction4_;
std::string scheduledAction3_;
std::string scheduledAction9_;
std::string scheduledAction8_;
std::string scheduledAction7_;
long ownerId_;
std::string scheduledTaskName20_;
std::string scheduledTaskName19_;
std::string scheduledTaskName18_;
std::string scheduledTaskId20_;
std::vector<std::string> scheduledAction_;
std::string scalingGroupId_;
std::string scheduledTaskName13_;
std::string scheduledTaskName12_;
std::string scheduledTaskName11_;
std::string scheduledTaskName10_;
std::string scheduledTaskName17_;
std::string scheduledTaskName16_;
std::string taskName_;
int pageNumber_;
std::string scheduledTaskName15_;
std::string accessKeyId_;
std::string scheduledTaskName14_;
std::string scheduledTaskId2_;
std::string scheduledTaskId1_;
std::string scheduledTaskId4_;
std::string scheduledTaskId18_;
std::string scheduledTaskId3_;
std::string scheduledTaskId19_;
std::string scheduledTaskId6_;
std::string regionId_;
std::string scheduledTaskId5_;
std::string scheduledTaskId8_;
std::string scheduledTaskName9_;
std::string scheduledAction20_;
std::string scheduledTaskId7_;
int pageSize_;
std::string scheduledTaskId12_;
std::string scheduledTaskName7_;
std::string scheduledTaskId9_;
std::string scheduledTaskId13_;
std::string scheduledTaskName8_;
std::string scheduledTaskId10_;
std::string scheduledTaskName5_;
std::string scheduledTaskId11_;
std::string scheduledTaskName6_;
std::string scheduledTaskId16_;
std::string scheduledTaskName3_;
std::string scheduledTaskId17_;
std::string scheduledTaskName4_;
std::string scheduledTaskId14_;
std::string scheduledTaskName1_;
std::string scheduledTaskId15_;
std::string scheduledTaskName2_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string scheduledAction18_;
std::string scheduledAction19_;
std::string scheduledAction16_;
std::string scheduledAction17_;
std::string scheduledAction14_;
std::string scheduledAction15_;
std::string scheduledAction12_;
std::string scheduledAction13_;
std::string scheduledAction10_;
std::string scheduledAction11_;
long ownerId_;
std::string recurrenceValue_;
std::vector<std::string> scheduledTaskName_;
bool taskEnabled_;
std::vector<std::string> scheduledTaskId_;
std::string recurrenceType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCHEDULEDTASKSREQUEST_H_

2
ess/include/alibabacloud/ess/model/DescribeScheduledTasksResult.h
View File

@@ -45,8 +45,8 @@ namespace AlibabaCloud
int launchExpirationTime;
int minValue;
std::string scheduledAction;
std::string recurrenceEndTime;
std::string recurrenceValue;
std::string recurrenceEndTime;
bool taskEnabled;
};

67
ess/include/alibabacloud/ess/model/DetachAlbServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_DETACHALBSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHALBSERVERGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DetachAlbServerGroupsRequest : public RpcServiceRequest {
public:
struct AlbServerGroup {
std::string albServerGroupId;
int port;
};
DetachAlbServerGroupsRequest();
~DetachAlbServerGroupsRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<AlbServerGroup> getAlbServerGroup() const;
void setAlbServerGroup(const std::vector<AlbServerGroup> &albServerGroup);
bool getForceDetach() const;
void setForceDetach(bool forceDetach);
private:
std::string clientToken_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::vector<AlbServerGroup> albServerGroup_;
bool forceDetach_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHALBSERVERGROUPSREQUEST_H_

51
ess/include/alibabacloud/ess/model/DetachAlbServerGroupsResult.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_ESS_MODEL_DETACHALBSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHALBSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DetachAlbServerGroupsResult : public ServiceResult
{
public:
DetachAlbServerGroupsResult();
explicit DetachAlbServerGroupsResult(const std::string &payload);
~DetachAlbServerGroupsResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHALBSERVERGROUPSRESULT_H_

32
ess/include/alibabacloud/ess/model/DetachDBInstancesRequest.h
View File

@@ -17,30 +17,29 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DETACHDBINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHDBINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DetachDBInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DetachDBInstancesRequest : public RpcServiceRequest {
public:
DetachDBInstancesRequest();
~DetachDBInstancesRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
bool getRemoveSecurityGroup() const;
void setRemoveSecurityGroup(bool removeSecurityGroup);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::vector<std::string> getDBInstance() const;
@@ -54,13 +53,14 @@ namespace AlibabaCloud
std::string clientToken_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
bool removeSecurityGroup_;
std::string resourceOwnerAccount_;
std::vector<std::string> dBInstance_;
long ownerId_;
bool forceDetach_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHDBINSTANCESREQUEST_H_

41
ess/include/alibabacloud/ess/model/DetachInstancesRequest.h
View File

@@ -17,56 +17,59 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DETACHINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DetachInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DetachInstancesRequest : public RpcServiceRequest {
public:
DetachInstancesRequest();
~DetachInstancesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
bool getDecreaseDesiredCapacity() const;
void setDecreaseDesiredCapacity(bool decreaseDesiredCapacity);
bool getIgnoreInvalidInstance() const;
void setIgnoreInvalidInstance(bool ignoreInvalidInstance);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<std::string> getInstanceId()const;
void setInstanceId(const std::vector<std::string>& instanceId);
std::string getDetachOption() const;
void setDetachOption(const std::string &detachOption);
std::vector<std::string> getInstanceId() const;
void setInstanceId(const std::vector<std::string> &instanceId);
bool getLifecycleHook() const;
void setLifecycleHook(bool lifecycleHook);
private:
long resourceOwnerId_;
std::string clientToken_;
std::string scalingGroupId_;
std::string accessKeyId_;
bool decreaseDesiredCapacity_;
bool ignoreInvalidInstance_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::vector<std::string> instanceId_;
std::string detachOption_;
std::vector<std::string> instanceId_;
bool lifecycleHook_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHINSTANCESREQUEST_H_

32
ess/include/alibabacloud/ess/model/DetachLoadBalancersRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DETACHLOADBALANCERSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHLOADBALANCERSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DetachLoadBalancersRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DetachLoadBalancersRequest : public RpcServiceRequest {
public:
DetachLoadBalancersRequest();
~DetachLoadBalancersRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
@@ -43,10 +38,14 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string &accessKeyId);
std::vector<std::string> getLoadBalancer() const;
void setLoadBalancer(const std::vector<std::string> &loadBalancer);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getAsync() const;
void setAsync(bool async);
bool getForceDetach() const;
void setForceDetach(bool forceDetach);
@@ -55,12 +54,13 @@ namespace AlibabaCloud
std::string scalingGroupId_;
std::string accessKeyId_;
std::vector<std::string> loadBalancer_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
bool async_;
bool forceDetach_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHLOADBALANCERSREQUEST_H_

2
ess/include/alibabacloud/ess/model/DetachLoadBalancersResult.h
View File

@@ -37,10 +37,12 @@ namespace AlibabaCloud
DetachLoadBalancersResult();
explicit DetachLoadBalancersResult(const std::string &payload);
~DetachLoadBalancersResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}

68
ess/include/alibabacloud/ess/model/DetachServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_ESS_MODEL_DETACHSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHSERVERGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DetachServerGroupsRequest : public RpcServiceRequest {
public:
struct ServerGroup {
std::string serverGroupId;
int port;
std::string type;
};
DetachServerGroupsRequest();
~DetachServerGroupsRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<ServerGroup> getServerGroup() const;
void setServerGroup(const std::vector<ServerGroup> &serverGroup);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getForceDetach() const;
void setForceDetach(bool forceDetach);
private:
std::string clientToken_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
std::vector<ServerGroup> serverGroup_;
std::string resourceOwnerAccount_;
long ownerId_;
bool forceDetach_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHSERVERGROUPSREQUEST_H_

51
ess/include/alibabacloud/ess/model/DetachServerGroupsResult.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_ESS_MODEL_DETACHSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DetachServerGroupsResult : public ServiceResult
{
public:
DetachServerGroupsResult();
explicit DetachServerGroupsResult(const std::string &payload);
~DetachServerGroupsResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHSERVERGROUPSRESULT_H_

33
ess/include/alibabacloud/ess/model/DetachVServerGroupsRequest.h
View File

@@ -17,35 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DETACHVSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DETACHVSERVERGROUPSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DetachVServerGroupsRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DetachVServerGroupsRequest : public RpcServiceRequest {
public:
struct VServerGroup
{
struct VServerGroup {
std::string loadBalancerId;
struct VServerGroupAttribute
{
struct VServerGroupAttribute {
std::string vServerGroupId;
int port;
};
std::vector<VServerGroupAttribute> vServerGroupAttribute;
};
public:
DetachVServerGroupsRequest();
~DetachVServerGroupsRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
@@ -72,9 +64,8 @@ namespace AlibabaCloud
long ownerId_;
bool forceDetach_;
std::vector<VServerGroup> vServerGroup_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DETACHVSERVERGROUPSREQUEST_H_

38
ess/include/alibabacloud/ess/model/DisableAlarmRequest.h
View File

@@ -17,44 +17,38 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DISABLEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DISABLEALARMREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DisableAlarmRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DisableAlarmRequest : public RpcServiceRequest {
public:
DisableAlarmRequest();
~DisableAlarmRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAlarmTaskId() const;
void setAlarmTaskId(const std::string &alarmTaskId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
std::string regionId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DISABLEALARMREQUEST_H_

38
ess/include/alibabacloud/ess/model/DisableScalingGroupRequest.h
View File

@@ -17,47 +17,41 @@
#ifndef ALIBABACLOUD_ESS_MODEL_DISABLESCALINGGROUPREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DISABLESCALINGGROUPREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT DisableScalingGroupRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT DisableScalingGroupRequest : public RpcServiceRequest {
public:
DisableScalingGroupRequest();
~DisableScalingGroupRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_DISABLESCALINGGROUPREQUEST_H_

38
ess/include/alibabacloud/ess/model/EnableAlarmRequest.h
View File

@@ -17,44 +17,38 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ENABLEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ENABLEALARMREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT EnableAlarmRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT EnableAlarmRequest : public RpcServiceRequest {
public:
EnableAlarmRequest();
~EnableAlarmRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAlarmTaskId() const;
void setAlarmTaskId(const std::string &alarmTaskId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
std::string regionId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ENABLEALARMREQUEST_H_

180
ess/include/alibabacloud/ess/model/EnableScalingGroupRequest.h
View File

@@ -17,176 +17,66 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ENABLESCALINGGROUPREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ENABLESCALINGGROUPREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT EnableScalingGroupRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT EnableScalingGroupRequest : public RpcServiceRequest {
public:
struct LaunchTemplateOverride {
int weightedCapacity;
std::string instanceType;
};
EnableScalingGroupRequest();
~EnableScalingGroupRequest();
int getLoadBalancerWeight6()const;
void setLoadBalancerWeight6(int loadBalancerWeight6);
int getLoadBalancerWeight11()const;
void setLoadBalancerWeight11(int loadBalancerWeight11);
int getLoadBalancerWeight7()const;
void setLoadBalancerWeight7(int loadBalancerWeight7);
int getLoadBalancerWeight12()const;
void setLoadBalancerWeight12(int loadBalancerWeight12);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getLoadBalancerWeight8()const;
void setLoadBalancerWeight8(int loadBalancerWeight8);
int getLoadBalancerWeight9()const;
void setLoadBalancerWeight9(int loadBalancerWeight9);
int getLoadBalancerWeight10()const;
void setLoadBalancerWeight10(int loadBalancerWeight10);
int getLoadBalancerWeight2()const;
void setLoadBalancerWeight2(int loadBalancerWeight2);
int getLoadBalancerWeight15()const;
void setLoadBalancerWeight15(int loadBalancerWeight15);
int getLoadBalancerWeight3()const;
void setLoadBalancerWeight3(int loadBalancerWeight3);
int getLoadBalancerWeight16()const;
void setLoadBalancerWeight16(int loadBalancerWeight16);
int getLoadBalancerWeight4()const;
void setLoadBalancerWeight4(int loadBalancerWeight4);
int getLoadBalancerWeight13()const;
void setLoadBalancerWeight13(int loadBalancerWeight13);
int getLoadBalancerWeight5()const;
void setLoadBalancerWeight5(int loadBalancerWeight5);
int getLoadBalancerWeight14()const;
void setLoadBalancerWeight14(int loadBalancerWeight14);
std::string getActiveScalingConfigurationId()const;
void setActiveScalingConfigurationId(const std::string& activeScalingConfigurationId);
int getLoadBalancerWeight1()const;
void setLoadBalancerWeight1(int loadBalancerWeight1);
std::string getInstanceId1()const;
void setInstanceId1(const std::string& instanceId1);
int getLoadBalancerWeight20()const;
void setLoadBalancerWeight20(int loadBalancerWeight20);
std::string getInstanceId3()const;
void setInstanceId3(const std::string& instanceId3);
std::string getLaunchTemplateId()const;
void setLaunchTemplateId(const std::string& launchTemplateId);
std::string getInstanceId2()const;
void setInstanceId2(const std::string& instanceId2);
std::string getInstanceId5()const;
void setInstanceId5(const std::string& instanceId5);
std::string getInstanceId4()const;
void setInstanceId4(const std::string& instanceId4);
std::string getInstanceId7()const;
void setInstanceId7(const std::string& instanceId7);
std::string getInstanceId6()const;
void setInstanceId6(const std::string& instanceId6);
std::string getInstanceId9()const;
void setInstanceId9(const std::string& instanceId9);
std::string getInstanceId8()const;
void setInstanceId8(const std::string& instanceId8);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getLoadBalancerWeight19()const;
void setLoadBalancerWeight19(int loadBalancerWeight19);
int getLoadBalancerWeight17()const;
void setLoadBalancerWeight17(int loadBalancerWeight17);
int getLoadBalancerWeight18()const;
void setLoadBalancerWeight18(int loadBalancerWeight18);
std::string getInstanceId10()const;
void setInstanceId10(const std::string& instanceId10);
std::string getInstanceId12()const;
void setInstanceId12(const std::string& instanceId12);
std::string getInstanceId11()const;
void setInstanceId11(const std::string& instanceId11);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getActiveScalingConfigurationId() const;
void setActiveScalingConfigurationId(const std::string &activeScalingConfigurationId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getInstanceId20()const;
void setInstanceId20(const std::string& instanceId20);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getLaunchTemplateId() const;
void setLaunchTemplateId(const std::string &launchTemplateId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::vector<LaunchTemplateOverride> getLaunchTemplateOverride() const;
void setLaunchTemplateOverride(const std::vector<LaunchTemplateOverride> &launchTemplateOverride);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getLaunchTemplateVersion() const;
void setLaunchTemplateVersion(const std::string &launchTemplateVersion);
std::string getInstanceId18()const;
void setInstanceId18(const std::string& instanceId18);
std::string getInstanceId17()const;
void setInstanceId17(const std::string& instanceId17);
std::string getInstanceId19()const;
void setInstanceId19(const std::string& instanceId19);
std::string getInstanceId14()const;
void setInstanceId14(const std::string& instanceId14);
std::string getInstanceId13()const;
void setInstanceId13(const std::string& instanceId13);
std::string getInstanceId16()const;
void setInstanceId16(const std::string& instanceId16);
std::string getInstanceId15()const;
void setInstanceId15(const std::string& instanceId15);
std::vector<std::string> getInstanceId() const;
void setInstanceId(const std::vector<std::string> &instanceId);
std::vector<int> getLoadBalancerWeight() const;
void setLoadBalancerWeight(const std::vector<int> &loadBalancerWeight);
private:
int loadBalancerWeight6_;
int loadBalancerWeight11_;
int loadBalancerWeight7_;
int loadBalancerWeight12_;
long resourceOwnerId_;
int loadBalancerWeight8_;
int loadBalancerWeight9_;
int loadBalancerWeight10_;
int loadBalancerWeight2_;
int loadBalancerWeight15_;
int loadBalancerWeight3_;
int loadBalancerWeight16_;
int loadBalancerWeight4_;
int loadBalancerWeight13_;
int loadBalancerWeight5_;
int loadBalancerWeight14_;
std::string activeScalingConfigurationId_;
int loadBalancerWeight1_;
std::string instanceId1_;
int loadBalancerWeight20_;
std::string instanceId3_;
std::string launchTemplateId_;
std::string instanceId2_;
std::string instanceId5_;
std::string instanceId4_;
std::string instanceId7_;
std::string instanceId6_;
std::string instanceId9_;
std::string instanceId8_;
long ownerId_;
int loadBalancerWeight19_;
int loadBalancerWeight17_;
int loadBalancerWeight18_;
std::string instanceId10_;
std::string instanceId12_;
std::string instanceId11_;
std::string scalingGroupId_;
std::string activeScalingConfigurationId_;
std::string accessKeyId_;
std::string instanceId20_;
std::string regionId_;
std::string launchTemplateId_;
std::string resourceOwnerAccount_;
std::vector<LaunchTemplateOverride> launchTemplateOverride_;
std::string ownerAccount_;
long ownerId_;
std::string launchTemplateVersion_;
std::string instanceId18_;
std::string instanceId17_;
std::string instanceId19_;
std::string instanceId14_;
std::string instanceId13_;
std::string instanceId16_;
std::string instanceId15_;
std::vector<std::string> instanceId_;
std::vector<int> loadBalancerWeight_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ENABLESCALINGGROUPREQUEST_H_

29
ess/include/alibabacloud/ess/model/EnterStandbyRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_ENTERSTANDBYREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ENTERSTANDBYREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT EnterStandbyRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT EnterStandbyRequest : public RpcServiceRequest {
public:
EnterStandbyRequest();
~EnterStandbyRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
@@ -45,6 +40,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getAsync() const;
void setAsync(bool async);
std::vector<std::string> getInstanceId() const;
void setInstanceId(const std::vector<std::string> &instanceId);
@@ -54,10 +51,10 @@ namespace AlibabaCloud
std::string accessKeyId_;
std::string resourceOwnerAccount_;
long ownerId_;
bool async_;
std::vector<std::string> instanceId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_ENTERSTANDBYREQUEST_H_

2
ess/include/alibabacloud/ess/model/EnterStandbyResult.h
View File

@@ -37,10 +37,12 @@ namespace AlibabaCloud
EnterStandbyResult();
explicit EnterStandbyResult(const std::string &payload);
~EnterStandbyResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}

29
ess/include/alibabacloud/ess/model/ExecuteScalingRuleRequest.h
View File

@@ -17,30 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_EXECUTESCALINGRULEREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_EXECUTESCALINGRULEREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ExecuteScalingRuleRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ExecuteScalingRuleRequest : public RpcServiceRequest {
public:
ExecuteScalingRuleRequest();
~ExecuteScalingRuleRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
float getBreachThreshold() const;
void setBreachThreshold(float breachThreshold);
std::string getResourceOwnerAccount() const;
@@ -58,15 +55,15 @@ namespace AlibabaCloud
long resourceOwnerId_;
std::string clientToken_;
std::string accessKeyId_;
std::string regionId_;
float breachThreshold_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
float metricValue_;
std::string scalingRuleAri_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_EXECUTESCALINGRULEREQUEST_H_

32
ess/include/alibabacloud/ess/model/ExitStandbyRequest.h
View File

@@ -17,34 +17,33 @@
#ifndef ALIBABACLOUD_ESS_MODEL_EXITSTANDBYREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_EXITSTANDBYREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ExitStandbyRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ExitStandbyRequest : public RpcServiceRequest {
public:
ExitStandbyRequest();
~ExitStandbyRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getAsync() const;
void setAsync(bool async);
std::vector<std::string> getInstanceId() const;
void setInstanceId(const std::vector<std::string> &instanceId);
@@ -52,12 +51,13 @@ namespace AlibabaCloud
std::string clientToken_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
bool async_;
std::vector<std::string> instanceId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_EXITSTANDBYREQUEST_H_

2
ess/include/alibabacloud/ess/model/ExitStandbyResult.h
View File

@@ -37,10 +37,12 @@ namespace AlibabaCloud
ExitStandbyResult();
explicit ExitStandbyResult(const std::string &payload);
~ExitStandbyResult();
std::string getScalingActivityId()const;
protected:
void parse(const std::string &payload);
private:
std::string scalingActivityId_;
};
}

26
ess/include/alibabacloud/ess/model/ListTagKeysRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_LISTTAGKEYSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_LISTTAGKEYSREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ListTagKeysRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ListTagKeysRequest : public RpcServiceRequest {
public:
ListTagKeysRequest();
~ListTagKeysRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
@@ -58,9 +53,8 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_LISTTAGKEYSREQUEST_H_

30
ess/include/alibabacloud/ess/model/ListTagResourcesRequest.h
View File

@@ -17,30 +17,23 @@
#ifndef ALIBABACLOUD_ESS_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ListTagResourcesRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ListTagResourcesRequest : public RpcServiceRequest {
public:
struct Tag
{
struct Tag {
std::string value;
std::string key;
};
public:
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
@@ -67,9 +60,8 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_LISTTAGRESOURCESREQUEST_H_

1
ess/include/alibabacloud/ess/model/ListTagResourcesResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
std::string resourceId;
std::string tagKey;
std::string resourceType;
bool propagate;
std::string tagValue;
};

26
ess/include/alibabacloud/ess/model/ListTagValuesRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_LISTTAGVALUESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_LISTTAGVALUESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ListTagValuesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ListTagValuesRequest : public RpcServiceRequest {
public:
ListTagValuesRequest();
~ListTagValuesRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
@@ -61,9 +56,8 @@ namespace AlibabaCloud
std::string resourceOwnerAccount_;
long ownerId_;
std::string resourceType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_LISTTAGVALUESREQUEST_H_

46
ess/include/alibabacloud/ess/model/ModifyAlarmRequest.h
View File

@@ -17,40 +17,40 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyAlarmRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyAlarmRequest : public RpcServiceRequest {
public:
struct Dimension
{
struct Dimension {
std::string dimensionValue;
std::string dimensionKey;
};
public:
struct Expression {
int period;
float threshold;
std::string metricName;
std::string comparisonOperator;
std::string statistics;
};
ModifyAlarmRequest();
~ModifyAlarmRequest();
std::string getMetricType() const;
void setMetricType(const std::string &metricType);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getExpressionsLogicOperator() const;
void setExpressionsLogicOperator(const std::string &expressionsLogicOperator);
std::vector<std::string> getAlarmAction() const;
void setAlarmAction(const std::vector<std::string> &alarmAction);
float getThreshold() const;
void setThreshold(float threshold);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getEffective() const;
void setEffective(const std::string &effective);
std::string getRegionId() const;
@@ -63,6 +63,8 @@ namespace AlibabaCloud
void setDimension(const std::vector<Dimension> &dimension);
int getPeriod() const;
void setPeriod(int period);
std::vector<Expression> getExpression() const;
void setExpression(const std::vector<Expression> &expression);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
int getGroupId() const;
@@ -81,15 +83,16 @@ namespace AlibabaCloud
private:
std::string metricType_;
std::string description_;
std::string expressionsLogicOperator_;
std::vector<std::string> alarmAction_;
float threshold_;
std::string accessKeyId_;
std::string effective_;
std::string regionId_;
int evaluationCount_;
std::string metricName_;
std::vector<Dimension> dimension_;
int period_;
std::vector<Expression> expression_;
std::string resourceOwnerAccount_;
int groupId_;
long ownerId_;
@@ -97,9 +100,8 @@ namespace AlibabaCloud
std::string name_;
std::string comparisonOperator_;
std::string statistics_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_

337
ess/include/alibabacloud/ess/model/ModifyEciScalingConfigurationRequest.h Normal file
View File

@@ -0,0 +1,337 @@
/*
* 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_ESS_MODEL_MODIFYECISCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYECISCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyEciScalingConfigurationRequest : public RpcServiceRequest {
public:
struct Container {
bool stdin;
int lifecyclePostStartHandlerHttpGetPort;
std::string workingDir;
int readinessProbeHttpGetPort;
int livenessProbeHttpGetPort;
int lifecyclePreStopHandlerTcpSocketPort;
struct VolumeMount {
std::string mountPath;
bool readOnly;
std::string mountPropagation;
std::string name;
std::string subPath;
};
std::vector<VolumeMount> volumeMount;
std::string image;
float cpu;
std::string readinessProbeHttpGetPath;
int gpu;
bool stdinOnce;
std::string lifecyclePostStartHandlerTcpSocketHost;
int livenessProbeSuccessThreshold;
long securityContextRunAsUser;
int livenessProbePeriodSeconds;
int livenessProbeInitialDelaySeconds;
struct Port {
std::string protocol;
int port;
};
std::vector<Port> port;
std::string name;
std::string lifecyclePreStopHandlerTcpSocketHost;
bool securityContextReadOnlyRootFilesystem;
std::string lifecyclePreStopHandlerHttpGetHost;
float memory;
std::string lifecyclePreStopHandlerHttpGetScheme;
int lifecyclePostStartHandlerTcpSocketPort;
std::string lifecyclePreStopHandlerHttpGetPath;
std::string lifecyclePostStartHandlerHttpGetHost;
int readinessProbeFailureThreshold;
int readinessProbeSuccessThreshold;
std::string lifecyclePostStartHandlerHttpGetPath;
int readinessProbeInitialDelaySeconds;
std::string readinessProbeHttpGetScheme;
int lifecyclePreStopHandlerHttpGetPort;
std::string imagePullPolicy;
std::string livenessProbeHttpGetPath;
std::string lifecyclePostStartHandlerHttpGetScheme;
int livenessProbeTimeoutSeconds;
int livenessProbeTcpSocketPort;
int readinessProbePeriodSeconds;
struct EnvironmentVar {
std::string fieldRefFieldPath;
std::string value;
std::string key;
};
std::vector<EnvironmentVar> environmentVar;
bool tty;
int livenessProbeFailureThreshold;
int readinessProbeTimeoutSeconds;
int readinessProbeTcpSocketPort;
std::string livenessProbeHttpGetScheme;
};
struct HostAliase {
std::string ip;
};
struct Tag {
std::string value;
std::string key;
};
struct Volume {
std::string diskVolumeFsType;
std::string emptyDirVolumeSizeLimit;
std::string nFSVolumePath;
std::string diskVolumeDiskId;
std::string flexVolumeFsType;
std::string type;
std::string flexVolumeDriver;
std::string flexVolumeOptions;
std::string nFSVolumeServer;
std::string emptyDirVolumeMedium;
std::string hostPathVolumePath;
std::string name;
struct ConfigFileVolumeConfigFileToPath {
int mode;
std::string path;
std::string content;
};
std::vector<ConfigFileVolumeConfigFileToPath> configFileVolumeConfigFileToPath;
int diskVolumeDiskSize;
int configFileVolumeDefaultMode;
std::string hostPathVolumeType;
bool nFSVolumeReadOnly;
};
struct DnsConfigOption {
std::string name;
std::string value;
};
struct SecurityContextSysctl {
std::string name;
std::string value;
};
struct InitContainer {
std::string image;
struct InitContainerEnvironmentVar {
std::string fieldRefFieldPath;
std::string value;
std::string key;
};
std::vector<InitContainerEnvironmentVar> initContainerEnvironmentVar;
float memory;
std::string workingDir;
float cpu;
int gpu;
std::string imagePullPolicy;
long securityContextRunAsUser;
struct InitContainerPort {
std::string protocol;
int port;
};
std::vector<InitContainerPort> initContainerPort;
std::string name;
struct InitContainerVolumeMount {
std::string mountPath;
bool readOnly;
std::string mountPropagation;
std::string name;
std::string subPath;
};
std::vector<InitContainerVolumeMount> initContainerVolumeMount;
bool securityContextReadOnlyRootFilesystem;
};
struct ImageRegistryCredential {
std::string server;
std::string password;
std::string userName;
};
struct AcrRegistryInfo {
std::string instanceName;
std::string instanceId;
std::string regionId;
};
ModifyEciScalingConfigurationRequest();
~ModifyEciScalingConfigurationRequest();
std::vector<Container> getContainer() const;
void setContainer(const std::vector<Container> &container);
std::vector<std::string> getNtpServer() const;
void setNtpServer(const std::vector<std::string> &ntpServer);
float getSpotPriceLimit() const;
void setSpotPriceLimit(float spotPriceLimit);
bool getEnableSls() const;
void setEnableSls(bool enableSls);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getHostName() const;
void setHostName(const std::string &hostName);
long getActiveDeadlineSeconds() const;
void setActiveDeadlineSeconds(long activeDeadlineSeconds);
long getEgressBandwidth() const;
void setEgressBandwidth(long egressBandwidth);
std::vector<std::string> getDnsConfigSearch() const;
void setDnsConfigSearch(const std::vector<std::string> &dnsConfigSearch);
std::vector<HostAliase> getHostAliase() const;
void setHostAliase(const std::vector<HostAliase> &hostAliase);
std::string getImageSnapshotId() const;
void setImageSnapshotId(const std::string &imageSnapshotId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
int getCpuOptionsThreadsPerCore() const;
void setCpuOptionsThreadsPerCore(int cpuOptionsThreadsPerCore);
std::string getDataCachePL() const;
void setDataCachePL(const std::string &dataCachePL);
int getIpv6AddressCount() const;
void setIpv6AddressCount(int ipv6AddressCount);
float getCpu() const;
void setCpu(float cpu);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationName() const;
void setScalingConfigurationName(const std::string &scalingConfigurationName);
std::string getScalingConfigurationId() const;
void setScalingConfigurationId(const std::string &scalingConfigurationId);
std::string getSpotStrategy() const;
void setSpotStrategy(const std::string &spotStrategy);
std::vector<Volume> getVolume() const;
void setVolume(const std::vector<Volume> &volume);
std::string getInstanceFamilyLevel() const;
void setInstanceFamilyLevel(const std::string &instanceFamilyLevel);
std::vector<DnsConfigOption> getDnsConfigOption() const;
void setDnsConfigOption(const std::vector<DnsConfigOption> &dnsConfigOption);
std::string getContainersUpdateType() const;
void setContainersUpdateType(const std::string &containersUpdateType);
int getEphemeralStorage() const;
void setEphemeralStorage(int ephemeralStorage);
int getDataCacheProvisionedIops() const;
void setDataCacheProvisionedIops(int dataCacheProvisionedIops);
int getEipBandwidth() const;
void setEipBandwidth(int eipBandwidth);
std::string getGpuDriverVersion() const;
void setGpuDriverVersion(const std::string &gpuDriverVersion);
bool getCostOptimization() const;
void setCostOptimization(bool costOptimization);
bool getDataCacheBurstingEnabled() const;
void setDataCacheBurstingEnabled(bool dataCacheBurstingEnabled);
float getMemory() const;
void setMemory(float memory);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::string getDescription() const;
void setDescription(const std::string &description);
long getIngressBandwidth() const;
void setIngressBandwidth(long ingressBandwidth);
std::string getDnsPolicy() const;
void setDnsPolicy(const std::string &dnsPolicy);
std::vector<SecurityContextSysctl> getSecurityContextSysctl() const;
void setSecurityContextSysctl(const std::vector<SecurityContextSysctl> &securityContextSysctl);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getDataCacheBucket() const;
void setDataCacheBucket(const std::string &dataCacheBucket);
std::vector<std::string> getDnsConfigNameServer() const;
void setDnsConfigNameServer(const std::vector<std::string> &dnsConfigNameServer);
std::vector<InitContainer> getInitContainer() const;
void setInitContainer(const std::vector<InitContainer> &initContainer);
std::vector<std::string> getInstanceType() const;
void setInstanceType(const std::vector<std::string> &instanceType);
long getTerminationGracePeriodSeconds() const;
void setTerminationGracePeriodSeconds(long terminationGracePeriodSeconds);
std::vector<ImageRegistryCredential> getImageRegistryCredential() const;
void setImageRegistryCredential(const std::vector<ImageRegistryCredential> &imageRegistryCredential);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getRestartPolicy() const;
void setRestartPolicy(const std::string &restartPolicy);
int getCpuOptionsCore() const;
void setCpuOptionsCore(int cpuOptionsCore);
std::string getRamRoleName() const;
void setRamRoleName(const std::string &ramRoleName);
std::vector<AcrRegistryInfo> getAcrRegistryInfo() const;
void setAcrRegistryInfo(const std::vector<AcrRegistryInfo> &acrRegistryInfo);
bool getAutoMatchImageCache() const;
void setAutoMatchImageCache(bool autoMatchImageCache);
int getLoadBalancerWeight() const;
void setLoadBalancerWeight(int loadBalancerWeight);
std::string getContainerGroupName() const;
void setContainerGroupName(const std::string &containerGroupName);
bool getAutoCreateEip() const;
void setAutoCreateEip(bool autoCreateEip);
private:
std::vector<Container> container_;
std::vector<std::string> ntpServer_;
float spotPriceLimit_;
bool enableSls_;
std::string resourceGroupId_;
std::string hostName_;
long activeDeadlineSeconds_;
long egressBandwidth_;
std::vector<std::string> dnsConfigSearch_;
std::vector<HostAliase> hostAliase_;
std::string imageSnapshotId_;
std::vector<Tag> tag_;
int cpuOptionsThreadsPerCore_;
std::string dataCachePL_;
int ipv6AddressCount_;
float cpu_;
long ownerId_;
std::string scalingConfigurationName_;
std::string scalingConfigurationId_;
std::string spotStrategy_;
std::vector<Volume> volume_;
std::string instanceFamilyLevel_;
std::vector<DnsConfigOption> dnsConfigOption_;
std::string containersUpdateType_;
int ephemeralStorage_;
int dataCacheProvisionedIops_;
int eipBandwidth_;
std::string gpuDriverVersion_;
bool costOptimization_;
bool dataCacheBurstingEnabled_;
float memory_;
std::string securityGroupId_;
std::string description_;
long ingressBandwidth_;
std::string dnsPolicy_;
std::vector<SecurityContextSysctl> securityContextSysctl_;
std::string accessKeyId_;
std::string dataCacheBucket_;
std::vector<std::string> dnsConfigNameServer_;
std::vector<InitContainer> initContainer_;
std::vector<std::string> instanceType_;
long terminationGracePeriodSeconds_;
std::vector<ImageRegistryCredential> imageRegistryCredential_;
std::string resourceOwnerAccount_;
std::string restartPolicy_;
int cpuOptionsCore_;
std::string ramRoleName_;
std::vector<AcrRegistryInfo> acrRegistryInfo_;
bool autoMatchImageCache_;
int loadBalancerWeight_;
std::string containerGroupName_;
bool autoCreateEip_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYECISCALINGCONFIGURATIONREQUEST_H_

49
ess/include/alibabacloud/ess/model/ModifyEciScalingConfigurationResult.h Normal file
View File

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

63
ess/include/alibabacloud/ess/model/ModifyInstanceAttributeRequest.h 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.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYINSTANCEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYINSTANCEATTRIBUTEREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyInstanceAttributeRequest : public RpcServiceRequest {
public:
ModifyInstanceAttributeRequest();
~ModifyInstanceAttributeRequest();
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getEntrusted() const;
void setEntrusted(bool entrusted);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::vector<std::string> getInstanceIds() const;
void setInstanceIds(const std::vector<std::string> &instanceIds);
private:
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
long ownerId_;
bool entrusted_;
std::string instanceId_;
std::vector<std::string> instanceIds_;
};
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYINSTANCEATTRIBUTEREQUEST_H_

49
ess/include/alibabacloud/ess/model/ModifyInstanceAttributeResult.h Normal file
View File

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

32
ess/include/alibabacloud/ess/model/ModifyLifecycleHookRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyLifecycleHookRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyLifecycleHookRequest : public RpcServiceRequest {
public:
ModifyLifecycleHookRequest();
~ModifyLifecycleHookRequest();
std::string getDefaultResult() const;
void setDefaultResult(const std::string &defaultResult);
int getHeartbeatTimeout() const;
@@ -47,8 +42,12 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string &accessKeyId);
std::string getLifecycleHookName() const;
void setLifecycleHookName(const std::string &lifecycleHookName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNotificationArn() const;
void setNotificationArn(const std::string &notificationArn);
std::string getLifecycleHookStatus() const;
void setLifecycleHookStatus(const std::string &lifecycleHookStatus);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getLifecycleHookId() const;
@@ -67,15 +66,16 @@ namespace AlibabaCloud
std::string lifecycleTransition_;
std::string accessKeyId_;
std::string lifecycleHookName_;
std::string regionId_;
std::string notificationArn_;
std::string lifecycleHookStatus_;
std::string resourceOwnerAccount_;
std::string lifecycleHookId_;
std::string ownerAccount_;
std::string notificationMetadata_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKREQUEST_H_

32
ess/include/alibabacloud/ess/model/ModifyNotificationConfigurationRequest.h
View File

@@ -17,28 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYNOTIFICATIONCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYNOTIFICATIONCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyNotificationConfigurationRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyNotificationConfigurationRequest : public RpcServiceRequest {
public:
ModifyNotificationConfigurationRequest();
~ModifyNotificationConfigurationRequest();
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getTimeZone() const;
void setTimeZone(const std::string &timeZone);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNotificationArn() const;
void setNotificationArn(const std::string &notificationArn);
std::string getResourceOwnerAccount() const;
@@ -50,14 +49,15 @@ namespace AlibabaCloud
private:
std::string scalingGroupId_;
std::string timeZone_;
std::string accessKeyId_;
std::string regionId_;
std::string notificationArn_;
std::string resourceOwnerAccount_;
long ownerId_;
std::vector<std::string> notificationType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYNOTIFICATIONCONFIGURATIONREQUEST_H_

162
ess/include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h
View File

@@ -17,65 +17,117 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGCONFIGURATIONREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGCONFIGURATIONREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyScalingConfigurationRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyScalingConfigurationRequest : public RpcServiceRequest {
public:
struct SpotPriceLimit
{
struct SecurityOptions {
std::string confidentialComputingMode;
};
struct SpotPriceLimit {
std::string instanceType;
float priceLimit;
};
struct DataDisk
{
std::string diskName;
struct CustomPriorities {
std::string vswitchId;
std::string instanceType;
};
struct CpuOptions {
std::string string;
std::vector<std::string> accelerators;
};
struct InstancePatternInfo {
float memory;
int maximumCpuCoreCount;
float maxPrice;
int minimumGpuAmount;
int maximumGpuAmount;
float maximumMemorySize;
int minimumInitialCredit;
int minimumEniIpv6AddressQuantity;
int minimumEniPrivateIpAddressQuantity;
std::string burstablePerformance;
int minimumCpuCoreCount;
int minimumEniQuantity;
float minimumMemorySize;
int cores;
std::string instanceFamilyLevel;
int minimumBaselineCredit;
};
struct NetworkInterfaces {
int ipv6AddressCount;
std::string instanceType;
std::string networkInterfaceTrafficMode;
};
struct ResourcePoolOptions {
std::string strategy;
std::string string;
std::vector<std::string> privatePoolIds;
};
struct DataDisk {
std::string snapshotId;
int size;
std::string encrypted;
std::string performanceLevel;
std::string autoSnapshotPolicyId;
std::string description;
bool burstingEnabled;
std::string diskName;
long provisionedIops;
std::string encrypted;
int size;
std::string category;
std::string kMSKeyId;
std::string device;
bool deleteWithInstance;
};
public:
struct InstanceTypeOverride {
int weightedCapacity;
std::string instanceType;
};
ModifyScalingConfigurationRequest();
~ModifyScalingConfigurationRequest();
std::string getHpcClusterId() const;
void setHpcClusterId(const std::string &hpcClusterId);
SecurityOptions getSecurityOptions() const;
void setSecurityOptions(const SecurityOptions &securityOptions);
std::string getKeyPairName() const;
void setKeyPairName(const std::string &keyPairName);
std::vector<SpotPriceLimit> getSpotPriceLimit() const;
void setSpotPriceLimit(const std::vector<SpotPriceLimit> &spotPriceLimit);
bool getDeletionProtection() const;
void setDeletionProtection(bool deletionProtection);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getPrivatePoolOptionsMatchCriteria() const;
void setPrivatePoolOptionsMatchCriteria(const std::string &privatePoolOptionsMatchCriteria);
std::string getHostName() const;
void setHostName(const std::string &hostName);
std::string getPassword() const;
void setPassword(const std::string &password);
std::string getInstanceDescription() const;
void setInstanceDescription(const std::string &instanceDescription);
int getStorageSetPartitionNumber() const;
void setStorageSetPartitionNumber(int storageSetPartitionNumber);
std::vector<CustomPriorities> getCustomPriorities() const;
void setCustomPriorities(const std::vector<CustomPriorities> &customPriorities);
std::string getSystemDiskAutoSnapshotPolicyId() const;
void setSystemDiskAutoSnapshotPolicyId(const std::string &systemDiskAutoSnapshotPolicyId);
std::string getPrivatePoolOptionsId() const;
void setPrivatePoolOptionsId(const std::string &privatePoolOptionsId);
bool getImageOptionsLoginAsNonRoot() const;
void setImageOptionsLoginAsNonRoot(bool imageOptionsLoginAsNonRoot);
int getIpv6AddressCount() const;
void setIpv6AddressCount(int ipv6AddressCount);
int getCpu() const;
void setCpu(int cpu);
std::vector<std::string> getSystemDiskCategories() const;
void setSystemDiskCategories(const std::vector<std::string> &systemDiskCategories);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getScalingConfigurationName() const;
@@ -86,18 +138,30 @@ namespace AlibabaCloud
void setScalingConfigurationId(const std::string &scalingConfigurationId);
std::string getSpotStrategy() const;
void setSpotStrategy(const std::string &spotStrategy);
CpuOptions getCpuOptions() const;
void setCpuOptions(const CpuOptions &cpuOptions);
bool getSystemDiskBurstingEnabled() const;
void setSystemDiskBurstingEnabled(bool systemDiskBurstingEnabled);
std::string getInstanceName() const;
void setInstanceName(const std::string &instanceName);
std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
int getInternetMaxBandwidthIn() const;
void setInternetMaxBandwidthIn(int internetMaxBandwidthIn);
std::vector<InstancePatternInfo> getInstancePatternInfo() const;
void setInstancePatternInfo(const std::vector<InstancePatternInfo> &instancePatternInfo);
std::string getAffinity() const;
void setAffinity(const std::string &affinity);
std::vector<NetworkInterfaces> getNetworkInterfaces() const;
void setNetworkInterfaces(const std::vector<NetworkInterfaces> &networkInterfaces);
std::string getImageId() const;
void setImageId(const std::string &imageId);
int getMemory() const;
void setMemory(int memory);
std::string getSpotInterruptionBehavior() const;
void setSpotInterruptionBehavior(const std::string &spotInterruptionBehavior);
std::string getIoOptimized() const;
void setIoOptimized(const std::string &ioOptimized);
std::vector<std::string> getInstanceTypes() const;
@@ -106,20 +170,30 @@ namespace AlibabaCloud
void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::string getSystemDiskKMSKeyId() const;
void setSystemDiskKMSKeyId(const std::string &systemDiskKMSKeyId);
std::string getSystemDiskCategory() const;
void setSystemDiskCategory(const std::string &systemDiskCategory);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getSystemDiskPerformanceLevel() const;
void setSystemDiskPerformanceLevel(const std::string &systemDiskPerformanceLevel);
std::string getUserData() const;
void setUserData(const std::string &userData);
bool getPasswordInherit() const;
void setPasswordInherit(bool passwordInherit);
ResourcePoolOptions getResourcePoolOptions() const;
void setResourcePoolOptions(const ResourcePoolOptions &resourcePoolOptions);
std::string getImageName() const;
void setImageName(const std::string &imageName);
std::string getHttpEndpoint() const;
void setHttpEndpoint(const std::string &httpEndpoint);
std::string getDedicatedHostClusterId() const;
void setDedicatedHostClusterId(const std::string &dedicatedHostClusterId);
bool getOverride() const;
void setOverride(bool override);
std::map<std::string, std::string> getSchedulerOptions() const;
void setSchedulerOptions(const std::map<std::string, std::string>& schedulerOptions);
void setSchedulerOptions(std::map<std::string, std::string> schedulerOptions);
std::string getDeploymentSetId() const;
void setDeploymentSetId(const std::string &deploymentSetId);
std::string getResourceOwnerAccount() const;
@@ -132,55 +206,87 @@ namespace AlibabaCloud
void setSystemDiskDiskName(const std::string &systemDiskDiskName);
std::string getRamRoleName() const;
void setRamRoleName(const std::string &ramRoleName);
std::string getSystemDiskEncryptAlgorithm() const;
void setSystemDiskEncryptAlgorithm(const std::string &systemDiskEncryptAlgorithm);
std::string getDedicatedHostId() const;
void setDedicatedHostId(const std::string &dedicatedHostId);
std::string getCreditSpecification() const;
void setCreditSpecification(const std::string &creditSpecification);
int getSpotDuration() const;
void setSpotDuration(int spotDuration);
std::vector<std::string> getSecurityGroupIds() const;
void setSecurityGroupIds(const std::vector<std::string> &securityGroupIds);
std::vector<DataDisk> getDataDisk() const;
void setDataDisk(const std::vector<DataDisk> &dataDisk);
std::vector<InstanceTypeOverride> getInstanceTypeOverride() const;
void setInstanceTypeOverride(const std::vector<InstanceTypeOverride> &instanceTypeOverride);
long getSystemDiskProvisionedIops() const;
void setSystemDiskProvisionedIops(long systemDiskProvisionedIops);
int getLoadBalancerWeight() const;
void setLoadBalancerWeight(int loadBalancerWeight);
std::string getStorageSetId() const;
void setStorageSetId(const std::string &storageSetId);
int getSystemDiskSize() const;
void setSystemDiskSize(int systemDiskSize);
std::string getImageFamily() const;
void setImageFamily(const std::string &imageFamily);
std::string getHttpTokens() const;
void setHttpTokens(const std::string &httpTokens);
std::string getSystemDiskDescription() const;
void setSystemDiskDescription(const std::string &systemDiskDescription);
bool getSystemDiskEncrypted() const;
void setSystemDiskEncrypted(bool systemDiskEncrypted);
private:
std::string hpcClusterId_;
SecurityOptions securityOptions_;
std::string keyPairName_;
std::vector<SpotPriceLimit> spotPriceLimit_;
bool deletionProtection_;
std::string resourceGroupId_;
std::string privatePoolOptionsMatchCriteria_;
std::string hostName_;
std::string password_;
std::string instanceDescription_;
int storageSetPartitionNumber_;
std::vector<CustomPriorities> customPriorities_;
std::string systemDiskAutoSnapshotPolicyId_;
std::string privatePoolOptionsId_;
bool imageOptionsLoginAsNonRoot_;
int ipv6AddressCount_;
int cpu_;
std::vector<std::string> systemDiskCategories_;
long ownerId_;
std::string scalingConfigurationName_;
std::string tags_;
std::string scalingConfigurationId_;
std::string spotStrategy_;
CpuOptions cpuOptions_;
bool systemDiskBurstingEnabled_;
std::string instanceName_;
std::string internetChargeType_;
std::string zoneId_;
int internetMaxBandwidthIn_;
std::vector<InstancePatternInfo> instancePatternInfo_;
std::string affinity_;
std::vector<NetworkInterfaces> networkInterfaces_;
std::string imageId_;
int memory_;
std::string spotInterruptionBehavior_;
std::string ioOptimized_;
std::vector<std::string> instanceTypes_;
int internetMaxBandwidthOut_;
std::string securityGroupId_;
std::string systemDiskKMSKeyId_;
std::string systemDiskCategory_;
std::string accessKeyId_;
std::string systemDiskPerformanceLevel_;
std::string userData_;
bool passwordInherit_;
ResourcePoolOptions resourcePoolOptions_;
std::string imageName_;
std::string httpEndpoint_;
std::string dedicatedHostClusterId_;
bool override_;
std::map<std::string, std::string> schedulerOptions_;
std::string deploymentSetId_;
@@ -189,17 +295,23 @@ namespace AlibabaCloud
std::string tenancy_;
std::string systemDiskDiskName_;
std::string ramRoleName_;
std::string systemDiskEncryptAlgorithm_;
std::string dedicatedHostId_;
std::string creditSpecification_;
int spotDuration_;
std::vector<std::string> securityGroupIds_;
std::vector<DataDisk> dataDisk_;
std::vector<InstanceTypeOverride> instanceTypeOverride_;
long systemDiskProvisionedIops_;
int loadBalancerWeight_;
std::string storageSetId_;
int systemDiskSize_;
std::string imageFamily_;
std::string httpTokens_;
std::string systemDiskDescription_;
bool systemDiskEncrypted_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGCONFIGURATIONREQUEST_H_

137
ess/include/alibabacloud/ess/model/ModifyScalingGroupRequest.h
View File

@@ -17,104 +17,149 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGGROUPREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGGROUPREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyScalingGroupRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyScalingGroupRequest : public RpcServiceRequest {
public:
struct LaunchTemplateOverride {
int weightedCapacity;
std::string instanceType;
float spotPriceLimit;
};
struct CapacityOptions {
bool compensateWithOnDemand;
std::string priceComparisonMode;
int onDemandBaseCapacity;
bool spotAutoReplaceOnDemand;
int onDemandPercentageAboveBaseCapacity;
};
ModifyScalingGroupRequest();
~ModifyScalingGroupRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScalingGroupId()const;
void setScalingGroupId(const std::string& scalingGroupId);
bool getAzBalance() const;
void setAzBalance(bool azBalance);
std::vector<std::string> getVSwitchIds() const;
void setVSwitchIds(const std::vector<std::string> &vSwitchIds);
int getMaxInstanceLifetime() const;
void setMaxInstanceLifetime(int maxInstanceLifetime);
std::string getActiveScalingConfigurationId() const;
void setActiveScalingConfigurationId(const std::string &activeScalingConfigurationId);
bool getSpotInstanceRemedy() const;
void setSpotInstanceRemedy(bool spotInstanceRemedy);
bool getScaleOutAmountCheck() const;
void setScaleOutAmountCheck(bool scaleOutAmountCheck);
std::string getCustomPolicyARN() const;
void setCustomPolicyARN(const std::string &customPolicyARN);
int getStopInstanceTimeout() const;
void setStopInstanceTimeout(int stopInstanceTimeout);
int getDefaultCooldown() const;
void setDefaultCooldown(int defaultCooldown);
std::vector<std::string> getHealthCheckTypes() const;
void setHealthCheckTypes(const std::vector<std::string> &healthCheckTypes);
std::string getMultiAZPolicy() const;
void setMultiAZPolicy(const std::string &multiAZPolicy);
std::string getLaunchTemplateId() const;
void setLaunchTemplateId(const std::string &launchTemplateId);
int getDesiredCapacity() const;
void setDesiredCapacity(int desiredCapacity);
std::vector<LaunchTemplateOverride> getLaunchTemplateOverride() const;
void setLaunchTemplateOverride(const std::vector<LaunchTemplateOverride> &launchTemplateOverride);
bool getCompensateWithOnDemand() const;
void setCompensateWithOnDemand(bool compensateWithOnDemand);
CapacityOptions getCapacityOptions() const;
void setCapacityOptions(const CapacityOptions &capacityOptions);
int getMinSize() const;
void setMinSize(int minSize);
long getOwnerId() const;
void setOwnerId(long ownerId);
int getMaxSize() const;
void setMaxSize(int maxSize);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
int getOnDemandBaseCapacity() const;
void setOnDemandBaseCapacity(int onDemandBaseCapacity);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
int getOnDemandPercentageAboveBaseCapacity() const;
void setOnDemandPercentageAboveBaseCapacity(int onDemandPercentageAboveBaseCapacity);
bool getSpotInstanceRemedy()const;
void setSpotInstanceRemedy(bool spotInstanceRemedy);
bool getScaleOutAmountCheck()const;
void setScaleOutAmountCheck(bool scaleOutAmountCheck);
int getDefaultCooldown()const;
void setDefaultCooldown(int defaultCooldown);
std::string getSpotAllocationStrategy() const;
void setSpotAllocationStrategy(const std::string &spotAllocationStrategy);
bool getDisableDesiredCapacity() const;
void setDisableDesiredCapacity(bool disableDesiredCapacity);
std::string getRemovalPolicy1() const;
void setRemovalPolicy1(const std::string &removalPolicy1);
std::string getRemovalPolicy2() const;
void setRemovalPolicy2(const std::string &removalPolicy2);
std::string getRemovalPolicy3() const;
void setRemovalPolicy3(const std::string &removalPolicy3);
std::string getHealthCheckType() const;
void setHealthCheckType(const std::string &healthCheckType);
std::string getLaunchTemplateId()const;
void setLaunchTemplateId(const std::string& launchTemplateId);
int getDesiredCapacity()const;
void setDesiredCapacity(int desiredCapacity);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getScalingGroupName() const;
void setScalingGroupName(const std::string &scalingGroupName);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
bool getCompensateWithOnDemand()const;
void setCompensateWithOnDemand(bool compensateWithOnDemand);
int getSpotInstancePools() const;
void setSpotInstancePools(int spotInstancePools);
int getMinSize()const;
void setMinSize(int minSize);
bool getGroupDeletionProtection() const;
void setGroupDeletionProtection(bool groupDeletionProtection);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getLaunchTemplateVersion() const;
void setLaunchTemplateVersion(const std::string &launchTemplateVersion);
int getMaxSize()const;
void setMaxSize(int maxSize);
std::string getScalingPolicy() const;
void setScalingPolicy(const std::string &scalingPolicy);
std::string getAllocationStrategy() const;
void setAllocationStrategy(const std::string &allocationStrategy);
private:
long resourceOwnerId_;
std::string scalingGroupId_;
bool azBalance_;
std::vector<std::string> vSwitchIds_;
int maxInstanceLifetime_;
std::string activeScalingConfigurationId_;
bool spotInstanceRemedy_;
bool scaleOutAmountCheck_;
std::string customPolicyARN_;
int stopInstanceTimeout_;
int defaultCooldown_;
std::vector<std::string> healthCheckTypes_;
std::string multiAZPolicy_;
std::string launchTemplateId_;
int desiredCapacity_;
std::vector<LaunchTemplateOverride> launchTemplateOverride_;
bool compensateWithOnDemand_;
CapacityOptions capacityOptions_;
int minSize_;
long ownerId_;
int maxSize_;
std::string scalingGroupId_;
int onDemandBaseCapacity_;
std::string accessKeyId_;
int onDemandPercentageAboveBaseCapacity_;
bool spotInstanceRemedy_;
bool scaleOutAmountCheck_;
int defaultCooldown_;
std::string spotAllocationStrategy_;
bool disableDesiredCapacity_;
std::string removalPolicy1_;
std::string removalPolicy2_;
std::string removalPolicy3_;
std::string healthCheckType_;
std::string launchTemplateId_;
int desiredCapacity_;
std::string resourceOwnerAccount_;
std::string scalingGroupName_;
std::string ownerAccount_;
bool compensateWithOnDemand_;
int spotInstancePools_;
int minSize_;
bool groupDeletionProtection_;
long ownerId_;
std::string launchTemplateVersion_;
int maxSize_;
std::string scalingPolicy_;
std::string allocationStrategy_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGGROUPREQUEST_H_

59
ess/include/alibabacloud/ess/model/ModifyScalingRuleRequest.h
View File

@@ -17,33 +17,45 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGRULEREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGRULEREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
#include <map>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyScalingRuleRequest : public RpcServiceRequest
{
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyScalingRuleRequest : public RpcServiceRequest {
public:
struct StepAdjustment
{
float metricIntervalLowerBound;
struct AlarmDimension {
std::string dimensionValue;
std::string dimensionKey;
};
struct StepAdjustment {
float metricIntervalUpperBound;
float metricIntervalLowerBound;
int scalingAdjustment;
};
public:
struct HybridMetrics {
std::string statistic;
std::string expression;
std::string id;
std::string metricName;
struct Dimensions {
std::string dimensionValue;
std::string dimensionKey;
};
std::vector<Dimensions> dimensions;
};
ModifyScalingRuleRequest();
~ModifyScalingRuleRequest();
std::string getMetricType() const;
void setMetricType(const std::string &metricType);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<AlarmDimension> getAlarmDimension() const;
void setAlarmDimension(const std::vector<AlarmDimension> &alarmDimension);
std::vector<StepAdjustment> getStepAdjustment() const;
void setStepAdjustment(const std::vector<StepAdjustment> &stepAdjustment);
bool getDisableScaleIn() const;
@@ -56,6 +68,8 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string &accessKeyId);
std::string getScalingRuleName() const;
void setScalingRuleName(const std::string &scalingRuleName);
std::string getHybridMonitorNamespace() const;
void setHybridMonitorNamespace(const std::string &hybridMonitorNamespace);
int getCooldown() const;
void setCooldown(int cooldown);
std::string getPredictiveValueBehavior() const;
@@ -82,6 +96,8 @@ namespace AlibabaCloud
void setOwnerId(long ownerId);
int getPredictiveValueBuffer() const;
void setPredictiveValueBuffer(int predictiveValueBuffer);
std::vector<HybridMetrics> getHybridMetrics() const;
void setHybridMetrics(const std::vector<HybridMetrics> &hybridMetrics);
int getScaleOutEvaluationCount() const;
void setScaleOutEvaluationCount(int scaleOutEvaluationCount);
int getMinAdjustmentMagnitude() const;
@@ -90,13 +106,16 @@ namespace AlibabaCloud
void setTargetValue(float targetValue);
private:
std::string metricType_;
long resourceOwnerId_;
std::vector<AlarmDimension> alarmDimension_;
std::vector<StepAdjustment> stepAdjustment_;
bool disableScaleIn_;
std::string scalingRuleId_;
int initialMaxSize_;
std::string accessKeyId_;
std::string scalingRuleName_;
std::string hybridMonitorNamespace_;
int cooldown_;
std::string predictiveValueBehavior_;
int scaleInEvaluationCount_;
@@ -110,12 +129,12 @@ namespace AlibabaCloud
std::string adjustmentType_;
long ownerId_;
int predictiveValueBuffer_;
std::vector<HybridMetrics> hybridMetrics_;
int scaleOutEvaluationCount_;
int minAdjustmentMagnitude_;
float targetValue_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGRULEREQUEST_H_

29
ess/include/alibabacloud/ess/model/ModifyScheduledTaskRequest.h
View File

@@ -17,24 +17,19 @@
#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYSCHEDULEDTASKREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYSCHEDULEDTASKREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT ModifyScheduledTaskRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT ModifyScheduledTaskRequest : public RpcServiceRequest {
public:
ModifyScheduledTaskRequest();
~ModifyScheduledTaskRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getScheduledAction() const;
@@ -49,6 +44,8 @@ namespace AlibabaCloud
void setRecurrenceEndTime(const std::string &recurrenceEndTime);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getLaunchTime() const;
void setLaunchTime(const std::string &launchTime);
int getDesiredCapacity() const;
@@ -82,6 +79,7 @@ namespace AlibabaCloud
std::string description_;
std::string recurrenceEndTime_;
std::string accessKeyId_;
std::string regionId_;
std::string launchTime_;
int desiredCapacity_;
std::string resourceOwnerAccount_;
@@ -94,9 +92,8 @@ namespace AlibabaCloud
bool taskEnabled_;
std::string scheduledTaskId_;
std::string recurrenceType_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCHEDULEDTASKREQUEST_H_

41
ess/include/alibabacloud/ess/model/RebalanceInstancesRequest.h
View File

@@ -17,47 +17,44 @@
#ifndef ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT RebalanceInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT RebalanceInstancesRequest : public RpcServiceRequest {
public:
RebalanceInstancesRequest();
~RebalanceInstancesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string scalingGroupId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESREQUEST_H_

29
ess/include/alibabacloud/ess/model/RecordLifecycleActionHeartbeatRequest.h
View File

@@ -17,30 +17,27 @@
#ifndef ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT RecordLifecycleActionHeartbeatRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT RecordLifecycleActionHeartbeatRequest : public RpcServiceRequest {
public:
RecordLifecycleActionHeartbeatRequest();
~RecordLifecycleActionHeartbeatRequest();
std::string getLifecycleActionToken() const;
void setLifecycleActionToken(const std::string &lifecycleActionToken);
int getHeartbeatTimeout() const;
void setHeartbeatTimeout(int heartbeatTimeout);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getLifecycleHookId() const;
@@ -54,13 +51,13 @@ namespace AlibabaCloud
std::string lifecycleActionToken_;
int heartbeatTimeout_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string lifecycleHookId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATREQUEST_H_

46
ess/include/alibabacloud/ess/model/RemoveInstancesRequest.h
View File

@@ -17,32 +17,42 @@
#ifndef ALIBABACLOUD_ESS_MODEL_REMOVEINSTANCESREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_REMOVEINSTANCESREQUEST_H_
#include <alibabacloud/ess/EssExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ess/EssExport.h>
namespace AlibabaCloud
{
namespace Ess
{
namespace Model
{
class ALIBABACLOUD_ESS_EXPORT RemoveInstancesRequest : public RpcServiceRequest
{
#include <map>
namespace AlibabaCloud {
namespace Ess {
namespace Model {
class ALIBABACLOUD_ESS_EXPORT RemoveInstancesRequest : public RpcServiceRequest {
public:
struct LifecycleHookContext {
bool disableLifecycleHook;
std::string string;
std::vector<std::string> ignoredLifecycleHookIds;
};
RemoveInstancesRequest();
~RemoveInstancesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getScalingGroupId() const;
void setScalingGroupId(const std::string &scalingGroupId);
LifecycleHookContext getLifecycleHookContext() const;
void setLifecycleHookContext(const LifecycleHookContext &lifecycleHookContext);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
bool getDecreaseDesiredCapacity() const;
void setDecreaseDesiredCapacity(bool decreaseDesiredCapacity);
bool getIgnoreInvalidInstance() const;
void setIgnoreInvalidInstance(bool ignoreInvalidInstance);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getStopInstanceTimeout() const;
void setStopInstanceTimeout(int stopInstanceTimeout);
std::string getRemovePolicy() const;
void setRemovePolicy(const std::string &removePolicy);
std::string getResourceOwnerAccount() const;
@@ -56,17 +66,21 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string clientToken_;
std::string scalingGroupId_;
LifecycleHookContext lifecycleHookContext_;
std::string accessKeyId_;
bool decreaseDesiredCapacity_;
bool ignoreInvalidInstance_;
std::string regionId_;
int stopInstanceTimeout_;
std::string removePolicy_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::vector<std::string> instanceId_;
};
}
}
}
} // namespace Model
} // namespace Ess
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ESS_MODEL_REMOVEINSTANCESREQUEST_H_

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