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

ESS SDK Auto Released By wujin.lhr,Version：1.22.5

Browse Source 
Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>
This commit is contained in:
yixiong.jxy
2018-08-16 23:15:24 +08:00
parent e5d87b63dc
commit 1c29ae37e8
44 changed files with 2367 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
ess/.DS_Store vendored
View File

Binary file not shown.

24
ess/CMakeLists.txt
View File

@@ -57,12 +57,20 @@ set(ess_public_header_model
include/alibabacloud/ess/model/DeleteNotificationConfigurationResult.h
include/alibabacloud/ess/model/DescribeLifecycleHooksRequest.h
include/alibabacloud/ess/model/DescribeLifecycleHooksResult.h
include/alibabacloud/ess/model/ModifyAlarmRequest.h
include/alibabacloud/ess/model/ModifyAlarmResult.h
include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h
include/alibabacloud/ess/model/DescribeAccountAttributesResult.h
include/alibabacloud/ess/model/DeleteAlarmRequest.h
include/alibabacloud/ess/model/DeleteAlarmResult.h
include/alibabacloud/ess/model/DescribeScalingActivityDetailRequest.h
include/alibabacloud/ess/model/DescribeScalingActivityDetailResult.h
include/alibabacloud/ess/model/DisableAlarmRequest.h
include/alibabacloud/ess/model/DisableAlarmResult.h
include/alibabacloud/ess/model/VerifyUserRequest.h
include/alibabacloud/ess/model/VerifyUserResult.h
include/alibabacloud/ess/model/DescribeAlarmsRequest.h
include/alibabacloud/ess/model/DescribeAlarmsResult.h
include/alibabacloud/ess/model/AttachInstancesRequest.h
include/alibabacloud/ess/model/AttachInstancesResult.h
include/alibabacloud/ess/model/DescribeScalingGroupsRequest.h
@@ -79,6 +87,8 @@ set(ess_public_header_model
include/alibabacloud/ess/model/ModifyLifecycleHookResult.h
include/alibabacloud/ess/model/DescribeScalingRulesRequest.h
include/alibabacloud/ess/model/DescribeScalingRulesResult.h
include/alibabacloud/ess/model/CreateAlarmRequest.h
include/alibabacloud/ess/model/CreateAlarmResult.h
include/alibabacloud/ess/model/EnableScalingGroupRequest.h
include/alibabacloud/ess/model/EnableScalingGroupResult.h
include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h
@@ -125,6 +135,8 @@ set(ess_public_header_model
include/alibabacloud/ess/model/AttachDBInstancesResult.h
include/alibabacloud/ess/model/CreateLifecycleHookRequest.h
include/alibabacloud/ess/model/CreateLifecycleHookResult.h
include/alibabacloud/ess/model/EnableAlarmRequest.h
include/alibabacloud/ess/model/EnableAlarmResult.h
include/alibabacloud/ess/model/ModifyAlertConfigRequest.h
include/alibabacloud/ess/model/ModifyAlertConfigResult.h )
@@ -166,12 +178,20 @@ set(ess_src
src/model/DeleteNotificationConfigurationResult.cc
src/model/DescribeLifecycleHooksRequest.cc
src/model/DescribeLifecycleHooksResult.cc
src/model/ModifyAlarmRequest.cc
src/model/ModifyAlarmResult.cc
src/model/DescribeAccountAttributesRequest.cc
src/model/DescribeAccountAttributesResult.cc
src/model/DeleteAlarmRequest.cc
src/model/DeleteAlarmResult.cc
src/model/DescribeScalingActivityDetailRequest.cc
src/model/DescribeScalingActivityDetailResult.cc
src/model/DisableAlarmRequest.cc
src/model/DisableAlarmResult.cc
src/model/VerifyUserRequest.cc
src/model/VerifyUserResult.cc
src/model/DescribeAlarmsRequest.cc
src/model/DescribeAlarmsResult.cc
src/model/AttachInstancesRequest.cc
src/model/AttachInstancesResult.cc
src/model/DescribeScalingGroupsRequest.cc
@@ -188,6 +208,8 @@ set(ess_src
src/model/ModifyLifecycleHookResult.cc
src/model/DescribeScalingRulesRequest.cc
src/model/DescribeScalingRulesResult.cc
src/model/CreateAlarmRequest.cc
src/model/CreateAlarmResult.cc
src/model/EnableScalingGroupRequest.cc
src/model/EnableScalingGroupResult.cc
src/model/DeactivateScalingConfigurationRequest.cc
@@ -234,6 +256,8 @@ set(ess_src
src/model/AttachDBInstancesResult.cc
src/model/CreateLifecycleHookRequest.cc
src/model/CreateLifecycleHookResult.cc
src/model/EnableAlarmRequest.cc
src/model/EnableAlarmResult.cc
src/model/ModifyAlertConfigRequest.cc
src/model/ModifyAlertConfigResult.cc )

BIN
ess/include/.DS_Store vendored
View File

Binary file not shown.

BIN
ess/include/alibabacloud/.DS_Store vendored
View File

Binary file not shown.

BIN
ess/include/alibabacloud/ess/.DS_Store vendored
View File

Binary file not shown.

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

@@ -58,12 +58,20 @@
#include "model/DeleteNotificationConfigurationResult.h"
#include "model/DescribeLifecycleHooksRequest.h"
#include "model/DescribeLifecycleHooksResult.h"
#include "model/ModifyAlarmRequest.h"
#include "model/ModifyAlarmResult.h"
#include "model/DescribeAccountAttributesRequest.h"
#include "model/DescribeAccountAttributesResult.h"
#include "model/DeleteAlarmRequest.h"
#include "model/DeleteAlarmResult.h"
#include "model/DescribeScalingActivityDetailRequest.h"
#include "model/DescribeScalingActivityDetailResult.h"
#include "model/DisableAlarmRequest.h"
#include "model/DisableAlarmResult.h"
#include "model/VerifyUserRequest.h"
#include "model/VerifyUserResult.h"
#include "model/DescribeAlarmsRequest.h"
#include "model/DescribeAlarmsResult.h"
#include "model/AttachInstancesRequest.h"
#include "model/AttachInstancesResult.h"
#include "model/DescribeScalingGroupsRequest.h"
@@ -80,6 +88,8 @@
#include "model/ModifyLifecycleHookResult.h"
#include "model/DescribeScalingRulesRequest.h"
#include "model/DescribeScalingRulesResult.h"
#include "model/CreateAlarmRequest.h"
#include "model/CreateAlarmResult.h"
#include "model/EnableScalingGroupRequest.h"
#include "model/EnableScalingGroupResult.h"
#include "model/DeactivateScalingConfigurationRequest.h"
@@ -126,6 +136,8 @@
#include "model/AttachDBInstancesResult.h"
#include "model/CreateLifecycleHookRequest.h"
#include "model/CreateLifecycleHookResult.h"
#include "model/EnableAlarmRequest.h"
#include "model/EnableAlarmResult.h"
#include "model/ModifyAlertConfigRequest.h"
#include "model/ModifyAlertConfigResult.h"
@@ -191,15 +203,27 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLifecycleHooksResult> DescribeLifecycleHooksOutcome;
typedef std::future<DescribeLifecycleHooksOutcome> DescribeLifecycleHooksOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeLifecycleHooksRequest&, const DescribeLifecycleHooksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLifecycleHooksAsyncHandler;
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::DescribeAccountAttributesResult> DescribeAccountAttributesOutcome;
typedef std::future<DescribeAccountAttributesOutcome> DescribeAccountAttributesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeAccountAttributesRequest&, const DescribeAccountAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAttributesAsyncHandler;
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::DescribeScalingActivityDetailResult> DescribeScalingActivityDetailOutcome;
typedef std::future<DescribeScalingActivityDetailOutcome> DescribeScalingActivityDetailOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeScalingActivityDetailRequest&, const DescribeScalingActivityDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivityDetailAsyncHandler;
typedef Outcome<Error, Model::DisableAlarmResult> DisableAlarmOutcome;
typedef std::future<DisableAlarmOutcome> DisableAlarmOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DisableAlarmRequest&, const DisableAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableAlarmAsyncHandler;
typedef Outcome<Error, Model::VerifyUserResult> VerifyUserOutcome;
typedef std::future<VerifyUserOutcome> VerifyUserOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::VerifyUserRequest&, const VerifyUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyUserAsyncHandler;
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::AttachInstancesResult> AttachInstancesOutcome;
typedef std::future<AttachInstancesOutcome> AttachInstancesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::AttachInstancesRequest&, const AttachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachInstancesAsyncHandler;
@@ -224,6 +248,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeScalingRulesResult> DescribeScalingRulesOutcome;
typedef std::future<DescribeScalingRulesOutcome> DescribeScalingRulesOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::DescribeScalingRulesRequest&, const DescribeScalingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingRulesAsyncHandler;
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::EnableScalingGroupResult> EnableScalingGroupOutcome;
typedef std::future<EnableScalingGroupOutcome> EnableScalingGroupOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::EnableScalingGroupRequest&, const EnableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableScalingGroupAsyncHandler;
@@ -293,6 +320,9 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::EnableAlarmResult> EnableAlarmOutcome;
typedef std::future<EnableAlarmOutcome> EnableAlarmOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::EnableAlarmRequest&, const EnableAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAlarmAsyncHandler;
typedef Outcome<Error, Model::ModifyAlertConfigResult> ModifyAlertConfigOutcome;
typedef std::future<ModifyAlertConfigOutcome> ModifyAlertConfigOutcomeCallable;
typedef std::function<void(const EssClient*, const Model::ModifyAlertConfigRequest&, const ModifyAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlertConfigAsyncHandler;
@@ -355,15 +385,27 @@ namespace AlibabaCloud
DescribeLifecycleHooksOutcome describeLifecycleHooks(const Model::DescribeLifecycleHooksRequest &request)const;
void describeLifecycleHooksAsync(const Model::DescribeLifecycleHooksRequest& request, const DescribeLifecycleHooksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLifecycleHooksOutcomeCallable describeLifecycleHooksCallable(const Model::DescribeLifecycleHooksRequest& request) const;
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;
DescribeAccountAttributesOutcome describeAccountAttributes(const Model::DescribeAccountAttributesRequest &request)const;
void describeAccountAttributesAsync(const Model::DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountAttributesOutcomeCallable describeAccountAttributesCallable(const Model::DescribeAccountAttributesRequest& request) const;
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;
DescribeScalingActivityDetailOutcome describeScalingActivityDetail(const Model::DescribeScalingActivityDetailRequest &request)const;
void describeScalingActivityDetailAsync(const Model::DescribeScalingActivityDetailRequest& request, const DescribeScalingActivityDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScalingActivityDetailOutcomeCallable describeScalingActivityDetailCallable(const Model::DescribeScalingActivityDetailRequest& request) const;
DisableAlarmOutcome disableAlarm(const Model::DisableAlarmRequest &request)const;
void disableAlarmAsync(const Model::DisableAlarmRequest& request, const DisableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableAlarmOutcomeCallable disableAlarmCallable(const Model::DisableAlarmRequest& request) const;
VerifyUserOutcome verifyUser(const Model::VerifyUserRequest &request)const;
void verifyUserAsync(const Model::VerifyUserRequest& request, const VerifyUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VerifyUserOutcomeCallable verifyUserCallable(const Model::VerifyUserRequest& request) const;
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;
AttachInstancesOutcome attachInstances(const Model::AttachInstancesRequest &request)const;
void attachInstancesAsync(const Model::AttachInstancesRequest& request, const AttachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachInstancesOutcomeCallable attachInstancesCallable(const Model::AttachInstancesRequest& request) const;
@@ -388,6 +430,9 @@ namespace AlibabaCloud
DescribeScalingRulesOutcome describeScalingRules(const Model::DescribeScalingRulesRequest &request)const;
void describeScalingRulesAsync(const Model::DescribeScalingRulesRequest& request, const DescribeScalingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScalingRulesOutcomeCallable describeScalingRulesCallable(const Model::DescribeScalingRulesRequest& 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;
EnableScalingGroupOutcome enableScalingGroup(const Model::EnableScalingGroupRequest &request)const;
void enableScalingGroupAsync(const Model::EnableScalingGroupRequest& request, const EnableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableScalingGroupOutcomeCallable enableScalingGroupCallable(const Model::EnableScalingGroupRequest& request) const;
@@ -457,6 +502,9 @@ namespace AlibabaCloud
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;
EnableAlarmOutcome enableAlarm(const Model::EnableAlarmRequest &request)const;
void enableAlarmAsync(const Model::EnableAlarmRequest& request, const EnableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableAlarmOutcomeCallable enableAlarmCallable(const Model::EnableAlarmRequest& request) const;
ModifyAlertConfigOutcome modifyAlertConfig(const Model::ModifyAlertConfigRequest &request)const;
void modifyAlertConfigAsync(const Model::ModifyAlertConfigRequest& request, const ModifyAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAlertConfigOutcomeCallable modifyAlertConfigCallable(const Model::ModifyAlertConfigRequest& request) const;

101
ess/include/alibabacloud/ess/model/CreateAlarmRequest.h Executable file
View File

@@ -0,0 +1,101 @@
/*
* 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_CREATEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_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 CreateAlarmRequest : public RpcServiceRequest
{
struct Dimension
{
std::string dimensionValue;
std::string dimensionKey;
};
public:
CreateAlarmRequest();
~CreateAlarmRequest();
std::string getMetricType()const;
void setMetricType(const std::string& metricType);
int getPeriod()const;
void setPeriod(int period);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getScalingGroupId()const;
void setScalingGroupId(const std::string& scalingGroupId);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string getDescription()const;
void setDescription(const std::string& description);
std::vector<std::string> getAlarmAction()const;
void setAlarmAction(const std::vector<std::string>& alarmAction);
float getThreshold()const;
void setThreshold(float threshold);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getComparisionOperator()const;
void setComparisionOperator(const std::string& comparisionOperator);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getName()const;
void setName(const std::string& name);
int getEvaluationCount()const;
void setEvaluationCount(int evaluationCount);
std::string getMetricName()const;
void setMetricName(const std::string& metricName);
std::vector<Dimension> getDimension()const;
void setDimension(const std::vector<Dimension>& dimension);
std::string getStatistics()const;
void setStatistics(const std::string& statistics);
private:
std::string metricType_;
int period_;
std::string resourceOwnerAccount_;
std::string scalingGroupId_;
std::string groupId_;
std::string description_;
std::vector<std::string> alarmAction_;
float threshold_;
long ownerId_;
std::string accessKeyId_;
std::string comparisionOperator_;
std::string regionId_;
std::string name_;
int evaluationCount_;
std::string metricName_;
std::vector<Dimension> dimension_;
std::string statistics_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_

51
ess/include/alibabacloud/ess/model/CreateAlarmResult.h Executable 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_CREATEALARMRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_CREATEALARMRESULT_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 CreateAlarmResult : public ServiceResult
{
public:
CreateAlarmResult();
explicit CreateAlarmResult(const std::string &payload);
~CreateAlarmResult();
std::string getAlarmTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string alarmTaskId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_CREATEALARMRESULT_H_

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

@@ -32,12 +32,12 @@ namespace AlibabaCloud
{
struct LifecycleHook
{
std::string lifecycleHookName;
std::string lifecycleTransition;
std::string defaultResult;
std::string lifecycleHookName;
int heartbeatTimeout;
std::string notificationMetadata;
std::string notificationArn;
std::string notificationMetadata;
std::string lifecycleTransition;
};
public:

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

@@ -35,25 +35,23 @@ namespace AlibabaCloud
std::string instanceType;
float priceLimit;
};
struct DataDisk
{
std::string snapshotId;
int size;
std::string category;
std::string device;
bool deleteWithInstance;
};
public:
CreateScalingConfigurationRequest();
~CreateScalingConfigurationRequest();
int getDataDisk3Size()const;
void setDataDisk3Size(int dataDisk3Size);
std::string getImageId()const;
void setImageId(const std::string& imageId);
std::string getDataDisk1SnapshotId()const;
void setDataDisk1SnapshotId(const std::string& dataDisk1SnapshotId);
std::string getDataDisk3Category()const;
void setDataDisk3Category(const std::string& dataDisk3Category);
std::string getDataDisk1Device()const;
void setDataDisk1Device(const std::string& dataDisk1Device);
std::string getScalingGroupId()const;
void setScalingGroupId(const std::string& scalingGroupId);
std::string getDataDisk2Device()const;
void setDataDisk2Device(const std::string& dataDisk2Device);
std::vector<std::string> getInstanceTypes()const;
void setInstanceTypes(const std::vector<std::string>& instanceTypes);
std::string getIoOptimized()const;
@@ -74,75 +72,44 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string& accessKeyId);
std::string getUserData()const;
void setUserData(const std::string& userData);
std::string getDataDisk4Category()const;
void setDataDisk4Category(const std::string& dataDisk4Category);
std::string getHostName()const;
void setHostName(const std::string& hostName);
std::string getDataDisk2SnapshotId()const;
void setDataDisk2SnapshotId(const std::string& dataDisk2SnapshotId);
bool getPasswordInherit()const;
void setPasswordInherit(bool passwordInherit);
int getDataDisk4Size()const;
void setDataDisk4Size(int dataDisk4Size);
std::string getImageName()const;
void setImageName(const std::string& imageName);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getDataDisk2Category()const;
void setDataDisk2Category(const std::string& dataDisk2Category);
int getDataDisk1Size()const;
void setDataDisk1Size(int dataDisk1Size);
std::string getDataDisk3SnapshotId()const;
void setDataDisk3SnapshotId(const std::string& dataDisk3SnapshotId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
int getDataDisk2Size()const;
void setDataDisk2Size(int dataDisk2Size);
std::string getRamRoleName()const;
void setRamRoleName(const std::string& ramRoleName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::vector<DataDisk> getDataDisk()const;
void setDataDisk(const std::vector<DataDisk>& dataDisk);
std::string getScalingConfigurationName()const;
void setScalingConfigurationName(const std::string& scalingConfigurationName);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getDataDisk2DeleteWithInstance()const;
void setDataDisk2DeleteWithInstance(const std::string& dataDisk2DeleteWithInstance);
std::string getSpotStrategy()const;
void setSpotStrategy(const std::string& spotStrategy);
std::string getDataDisk1Category()const;
void setDataDisk1Category(const std::string& dataDisk1Category);
std::string getDataDisk3DeleteWithInstance()const;
void setDataDisk3DeleteWithInstance(const std::string& dataDisk3DeleteWithInstance);
int getLoadBalancerWeight()const;
void setLoadBalancerWeight(int loadBalancerWeight);
std::string getInstanceName()const;
void setInstanceName(const std::string& instanceName);
int getSystemDiskSize()const;
void setSystemDiskSize(int systemDiskSize);
std::string getDataDisk4SnapshotId()const;
void setDataDisk4SnapshotId(const std::string& dataDisk4SnapshotId);
std::string getDataDisk4Device()const;
void setDataDisk4Device(const std::string& dataDisk4Device);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getDataDisk3Device()const;
void setDataDisk3Device(const std::string& dataDisk3Device);
std::string getDataDisk4DeleteWithInstance()const;
void setDataDisk4DeleteWithInstance(const std::string& dataDisk4DeleteWithInstance);
int getInternetMaxBandwidthIn()const;
void setInternetMaxBandwidthIn(int internetMaxBandwidthIn);
std::string getDataDisk1DeleteWithInstance()const;
void setDataDisk1DeleteWithInstance(const std::string& dataDisk1DeleteWithInstance);
private:
int dataDisk3Size_;
std::string imageId_;
std::string dataDisk1SnapshotId_;
std::string dataDisk3Category_;
std::string dataDisk1Device_;
std::string scalingGroupId_;
std::string dataDisk2Device_;
std::vector<std::string> instanceTypes_;
std::string ioOptimized_;
std::string securityGroupId_;
@@ -153,36 +120,23 @@ namespace AlibabaCloud
std::string systemDiskCategory_;
std::string accessKeyId_;
std::string userData_;
std::string dataDisk4Category_;
std::string hostName_;
std::string dataDisk2SnapshotId_;
bool passwordInherit_;
int dataDisk4Size_;
std::string imageName_;
std::string instanceType_;
std::string dataDisk2Category_;
int dataDisk1Size_;
std::string dataDisk3SnapshotId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
int dataDisk2Size_;
std::string ramRoleName_;
long ownerId_;
std::vector<DataDisk> dataDisk_;
std::string scalingConfigurationName_;
std::string tags_;
std::string dataDisk2DeleteWithInstance_;
std::string spotStrategy_;
std::string dataDisk1Category_;
std::string dataDisk3DeleteWithInstance_;
int loadBalancerWeight_;
std::string instanceName_;
int systemDiskSize_;
std::string dataDisk4SnapshotId_;
std::string dataDisk4Device_;
std::string internetChargeType_;
std::string dataDisk3Device_;
std::string dataDisk4DeleteWithInstance_;
int internetMaxBandwidthIn_;
std::string dataDisk1DeleteWithInstance_;
};
}

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

@@ -32,12 +32,12 @@ namespace AlibabaCloud
{
struct LifecycleHook
{
std::string lifecycleHookName;
std::string lifecycleTransition;
std::string defaultResult;
std::string lifecycleHookName;
int heartbeatTimeout;
std::string notificationMetadata;
std::string notificationArn;
std::string notificationMetadata;
std::string lifecycleTransition;
};
public:

60
ess/include/alibabacloud/ess/model/DeleteAlarmRequest.h Executable 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_DELETEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DELETEALARMREQUEST_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
{
public:
DeleteAlarmRequest();
~DeleteAlarmRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
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);
private:
std::string resourceOwnerAccount_;
std::string regionId_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DELETEALARMREQUEST_H_

51
ess/include/alibabacloud/ess/model/DeleteAlarmResult.h Executable 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_DELETEALARMRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DELETEALARMRESULT_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 DeleteAlarmResult : public ServiceResult
{
public:
DeleteAlarmResult();
explicit DeleteAlarmResult(const std::string &payload);
~DeleteAlarmResult();
std::string getAlarmTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string alarmTaskId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DELETEALARMRESULT_H_

78
ess/include/alibabacloud/ess/model/DescribeAlarmsRequest.h Executable file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_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
{
public:
DescribeAlarmsRequest();
~DescribeAlarmsRequest();
bool getIsEnable()const;
void setIsEnable(bool isEnable);
std::string getMetricType()const;
void setMetricType(const std::string& metricType);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getScalingGroupId()const;
void setScalingGroupId(const std::string& scalingGroupId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getState()const;
void setState(const std::string& state);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAlarmTaskId()const;
void setAlarmTaskId(const std::string& alarmTaskId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
bool isEnable_;
std::string metricType_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string scalingGroupId_;
int pageSize_;
std::string state_;
long ownerId_;
std::string alarmTaskId_;
int pageNumber_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_

75
ess/include/alibabacloud/ess/model/DescribeAlarmsResult.h Executable file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSRESULT_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 DescribeAlarmsResult : public ServiceResult
{
public:
struct Alarm
{
std::string comparisonOperator;
std::string description;
std::string scalingGroupId;
std::string metricType;
std::string dimensions;
int period;
int evaluationCount;
std::string statistics;
std::string name;
std::vector<std::string> alarmActions;
std::string metricName;
std::string state;
bool enable;
std::string alarmTaskId;
float threshold;
};
DescribeAlarmsResult();
explicit DescribeAlarmsResult(const std::string &payload);
~DescribeAlarmsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Alarm> getAlarmList()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<Alarm> alarmList_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSRESULT_H_

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

@@ -40,6 +40,7 @@ namespace AlibabaCloud
std::string category;
int size;
std::string device;
bool deleteWithInstance;
};
struct Tag
{
@@ -74,6 +75,7 @@ namespace AlibabaCloud
std::string systemDiskCategory;
std::string instanceName;
std::string deploymentSetId;
std::string imageName;
int internetMaxBandwidthOut;
int internetMaxBandwidthIn;
std::string creationTime;

60
ess/include/alibabacloud/ess/model/DisableAlarmRequest.h Executable 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_DISABLEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_DISABLEALARMREQUEST_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
{
public:
DisableAlarmRequest();
~DisableAlarmRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
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);
private:
std::string resourceOwnerAccount_;
std::string regionId_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DISABLEALARMREQUEST_H_

49
ess/include/alibabacloud/ess/model/DisableAlarmResult.h Executable 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_DISABLEALARMRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_DISABLEALARMRESULT_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 DisableAlarmResult : public ServiceResult
{
public:
DisableAlarmResult();
explicit DisableAlarmResult(const std::string &payload);
~DisableAlarmResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_DISABLEALARMRESULT_H_

60
ess/include/alibabacloud/ess/model/EnableAlarmRequest.h Executable 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_ENABLEALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_ENABLEALARMREQUEST_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
{
public:
EnableAlarmRequest();
~EnableAlarmRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
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);
private:
std::string resourceOwnerAccount_;
std::string regionId_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_ENABLEALARMREQUEST_H_

49
ess/include/alibabacloud/ess/model/EnableAlarmResult.h Executable 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_ENABLEALARMRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_ENABLEALARMRESULT_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 EnableAlarmResult : public ServiceResult
{
public:
EnableAlarmResult();
explicit EnableAlarmResult(const std::string &payload);
~EnableAlarmResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_ENABLEALARMRESULT_H_

69
ess/include/alibabacloud/ess/model/ModifyAlarmRequest.h Executable 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_MODIFYALARMREQUEST_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_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 ModifyAlarmRequest : public RpcServiceRequest
{
public:
ModifyAlarmRequest();
~ModifyAlarmRequest();
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getName()const;
void setName(const std::string& name);
std::string getDescription()const;
void setDescription(const std::string& description);
std::vector<std::string> getAlarmAction()const;
void setAlarmAction(const std::vector<std::string>& alarmAction);
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);
private:
std::string resourceOwnerAccount_;
std::string regionId_;
std::string name_;
std::string description_;
std::vector<std::string> alarmAction_;
long ownerId_;
std::string alarmTaskId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_

51
ess/include/alibabacloud/ess/model/ModifyAlarmResult.h Executable 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_MODIFYALARMRESULT_H_
#define ALIBABACLOUD_ESS_MODEL_MODIFYALARMRESULT_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 ModifyAlarmResult : public ServiceResult
{
public:
ModifyAlarmResult();
explicit ModifyAlarmResult(const std::string &payload);
~ModifyAlarmResult();
std::string getAlarmTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string alarmTaskId_;
};
}
}
}
#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYALARMRESULT_H_

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

@@ -30,6 +30,19 @@ namespace AlibabaCloud
{
class ALIBABACLOUD_ESS_EXPORT ModifyScalingConfigurationRequest : public RpcServiceRequest
{
struct SpotPriceLimit
{
std::string instanceType;
float priceLimit;
};
struct DataDisk
{
std::string snapshotId;
int size;
std::string category;
std::string device;
bool deleteWithInstance;
};
public:
ModifyScalingConfigurationRequest();
@@ -37,40 +50,50 @@ namespace AlibabaCloud
std::string getImageId()const;
void setImageId(const std::string& imageId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getIoOptimized()const;
void setIoOptimized(const std::string& ioOptimized);
std::vector<std::string> getInstanceTypes()const;
void setInstanceTypes(const std::vector<std::string>& instanceTypes);
int getInternetMaxBandwidthOut()const;
void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
std::string getRamRoleName()const;
void setRamRoleName(const std::string& ramRoleName);
std::string getKeyPairName()const;
void setKeyPairName(const std::string& keyPairName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::vector<SpotPriceLimit> getSpotPriceLimit()const;
void setSpotPriceLimit(const std::vector<SpotPriceLimit>& spotPriceLimit);
std::string getSystemDiskCategory()const;
void setSystemDiskCategory(const std::string& systemDiskCategory);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getUserData()const;
void setUserData(const std::string& userData);
std::string getHostName()const;
void setHostName(const std::string& hostName);
bool getPasswordInherit()const;
void setPasswordInherit(bool passwordInherit);
std::string getImageName()const;
void setImageName(const std::string& imageName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getRamRoleName()const;
void setRamRoleName(const std::string& ramRoleName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::vector<DataDisk> getDataDisk()const;
void setDataDisk(const std::vector<DataDisk>& dataDisk);
std::string getScalingConfigurationName()const;
void setScalingConfigurationName(const std::string& scalingConfigurationName);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getScalingConfigurationId()const;
void setScalingConfigurationId(const std::string& scalingConfigurationId);
std::string getUserData()const;
void setUserData(const std::string& userData);
std::string getHostName()const;
void setHostName(const std::string& hostName);
std::string getSpotStrategy()const;
void setSpotStrategy(const std::string& spotStrategy);
std::string getInstanceName()const;
void setInstanceName(const std::string& instanceName);
int getLoadBalancerWeight()const;
void setLoadBalancerWeight(int loadBalancerWeight);
bool getPasswordInherit()const;
void setPasswordInherit(bool passwordInherit);
int getSystemDiskSize()const;
void setSystemDiskSize(int systemDiskSize);
std::string getInternetChargeType()const;
@@ -78,23 +101,28 @@ namespace AlibabaCloud
private:
std::string imageId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string ioOptimized_;
std::vector<std::string> instanceTypes_;
int internetMaxBandwidthOut_;
std::string ramRoleName_;
std::string keyPairName_;
long ownerId_;
std::vector<SpotPriceLimit> spotPriceLimit_;
std::string systemDiskCategory_;
std::string accessKeyId_;
std::string userData_;
std::string hostName_;
bool passwordInherit_;
std::string imageName_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string ramRoleName_;
long ownerId_;
std::vector<DataDisk> dataDisk_;
std::string scalingConfigurationName_;
std::string tags_;
std::string scalingConfigurationId_;
std::string userData_;
std::string hostName_;
std::string spotStrategy_;
std::string instanceName_;
int loadBalancerWeight_;
bool passwordInherit_;
int systemDiskSize_;
std::string internetChargeType_;

BIN
ess/src/.DS_Store vendored
View File

Binary file not shown.

216
ess/src/EssClient.cc
View File

@@ -699,6 +699,42 @@ EssClient::DescribeLifecycleHooksOutcomeCallable EssClient::describeLifecycleHoo
return task->get_future();
}
EssClient::ModifyAlarmOutcome EssClient::modifyAlarm(const ModifyAlarmRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyAlarmOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyAlarmOutcome(ModifyAlarmResult(outcome.result()));
else
return ModifyAlarmOutcome(outcome.error());
}
void EssClient::modifyAlarmAsync(const ModifyAlarmRequest& request, const ModifyAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyAlarm(request), context);
};
asyncExecute(new Runnable(fn));
}
EssClient::ModifyAlarmOutcomeCallable EssClient::modifyAlarmCallable(const ModifyAlarmRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyAlarmOutcome()>>(
[this, request]()
{
return this->modifyAlarm(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EssClient::DescribeAccountAttributesOutcome EssClient::describeAccountAttributes(const DescribeAccountAttributesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,6 +771,42 @@ EssClient::DescribeAccountAttributesOutcomeCallable EssClient::describeAccountAt
return task->get_future();
}
EssClient::DeleteAlarmOutcome EssClient::deleteAlarm(const DeleteAlarmRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteAlarmOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteAlarmOutcome(DeleteAlarmResult(outcome.result()));
else
return DeleteAlarmOutcome(outcome.error());
}
void EssClient::deleteAlarmAsync(const DeleteAlarmRequest& request, const DeleteAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteAlarm(request), context);
};
asyncExecute(new Runnable(fn));
}
EssClient::DeleteAlarmOutcomeCallable EssClient::deleteAlarmCallable(const DeleteAlarmRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteAlarmOutcome()>>(
[this, request]()
{
return this->deleteAlarm(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EssClient::DescribeScalingActivityDetailOutcome EssClient::describeScalingActivityDetail(const DescribeScalingActivityDetailRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +843,42 @@ EssClient::DescribeScalingActivityDetailOutcomeCallable EssClient::describeScali
return task->get_future();
}
EssClient::DisableAlarmOutcome EssClient::disableAlarm(const DisableAlarmRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DisableAlarmOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DisableAlarmOutcome(DisableAlarmResult(outcome.result()));
else
return DisableAlarmOutcome(outcome.error());
}
void EssClient::disableAlarmAsync(const DisableAlarmRequest& request, const DisableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, disableAlarm(request), context);
};
asyncExecute(new Runnable(fn));
}
EssClient::DisableAlarmOutcomeCallable EssClient::disableAlarmCallable(const DisableAlarmRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DisableAlarmOutcome()>>(
[this, request]()
{
return this->disableAlarm(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EssClient::VerifyUserOutcome EssClient::verifyUser(const VerifyUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +915,42 @@ EssClient::VerifyUserOutcomeCallable EssClient::verifyUserCallable(const VerifyU
return task->get_future();
}
EssClient::DescribeAlarmsOutcome EssClient::describeAlarms(const DescribeAlarmsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeAlarmsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeAlarmsOutcome(DescribeAlarmsResult(outcome.result()));
else
return DescribeAlarmsOutcome(outcome.error());
}
void EssClient::describeAlarmsAsync(const DescribeAlarmsRequest& request, const DescribeAlarmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeAlarms(request), context);
};
asyncExecute(new Runnable(fn));
}
EssClient::DescribeAlarmsOutcomeCallable EssClient::describeAlarmsCallable(const DescribeAlarmsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeAlarmsOutcome()>>(
[this, request]()
{
return this->describeAlarms(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EssClient::AttachInstancesOutcome EssClient::attachInstances(const AttachInstancesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1095,6 +1239,42 @@ EssClient::DescribeScalingRulesOutcomeCallable EssClient::describeScalingRulesCa
return task->get_future();
}
EssClient::CreateAlarmOutcome EssClient::createAlarm(const CreateAlarmRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateAlarmOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateAlarmOutcome(CreateAlarmResult(outcome.result()));
else
return CreateAlarmOutcome(outcome.error());
}
void EssClient::createAlarmAsync(const CreateAlarmRequest& request, const CreateAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createAlarm(request), context);
};
asyncExecute(new Runnable(fn));
}
EssClient::CreateAlarmOutcomeCallable EssClient::createAlarmCallable(const CreateAlarmRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateAlarmOutcome()>>(
[this, request]()
{
return this->createAlarm(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EssClient::EnableScalingGroupOutcome EssClient::enableScalingGroup(const EnableScalingGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1923,6 +2103,42 @@ EssClient::CreateLifecycleHookOutcomeCallable EssClient::createLifecycleHookCall
return task->get_future();
}
EssClient::EnableAlarmOutcome EssClient::enableAlarm(const EnableAlarmRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EnableAlarmOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EnableAlarmOutcome(EnableAlarmResult(outcome.result()));
else
return EnableAlarmOutcome(outcome.error());
}
void EssClient::enableAlarmAsync(const EnableAlarmRequest& request, const EnableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, enableAlarm(request), context);
};
asyncExecute(new Runnable(fn));
}
EssClient::EnableAlarmOutcomeCallable EssClient::enableAlarmCallable(const EnableAlarmRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EnableAlarmOutcome()>>(
[this, request]()
{
return this->enableAlarm(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EssClient::ModifyAlertConfigOutcome EssClient::modifyAlertConfig(const ModifyAlertConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

221
ess/src/model/CreateAlarmRequest.cc Executable file
View File

@@ -0,0 +1,221 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/CreateAlarmRequest.h>
using AlibabaCloud::Ess::Model::CreateAlarmRequest;
CreateAlarmRequest::CreateAlarmRequest() :
RpcServiceRequest("ess", "2014-08-28", "CreateAlarm")
{}
CreateAlarmRequest::~CreateAlarmRequest()
{}
std::string CreateAlarmRequest::getMetricType()const
{
return metricType_;
}
void CreateAlarmRequest::setMetricType(const std::string& metricType)
{
metricType_ = metricType;
setParameter("MetricType", metricType);
}
int CreateAlarmRequest::getPeriod()const
{
return period_;
}
void CreateAlarmRequest::setPeriod(int period)
{
period_ = period;
setParameter("Period", std::to_string(period));
}
std::string CreateAlarmRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateAlarmRequest::getScalingGroupId()const
{
return scalingGroupId_;
}
void CreateAlarmRequest::setScalingGroupId(const std::string& scalingGroupId)
{
scalingGroupId_ = scalingGroupId;
setParameter("ScalingGroupId", scalingGroupId);
}
std::string CreateAlarmRequest::getGroupId()const
{
return groupId_;
}
void CreateAlarmRequest::setGroupId(const std::string& groupId)
{
groupId_ = groupId;
setParameter("GroupId", groupId);
}
std::string CreateAlarmRequest::getDescription()const
{
return description_;
}
void CreateAlarmRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::vector<std::string> CreateAlarmRequest::getAlarmAction()const
{
return alarmAction_;
}
void CreateAlarmRequest::setAlarmAction(const std::vector<std::string>& alarmAction)
{
alarmAction_ = alarmAction;
for(int i = 0; i!= alarmAction.size(); i++)
setParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
}
float CreateAlarmRequest::getThreshold()const
{
return threshold_;
}
void CreateAlarmRequest::setThreshold(float threshold)
{
threshold_ = threshold;
setParameter("Threshold", std::to_string(threshold));
}
long CreateAlarmRequest::getOwnerId()const
{
return ownerId_;
}
void CreateAlarmRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateAlarmRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateAlarmRequest::getComparisionOperator()const
{
return comparisionOperator_;
}
void CreateAlarmRequest::setComparisionOperator(const std::string& comparisionOperator)
{
comparisionOperator_ = comparisionOperator;
setParameter("ComparisionOperator", comparisionOperator);
}
std::string CreateAlarmRequest::getRegionId()const
{
return regionId_;
}
void CreateAlarmRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateAlarmRequest::getName()const
{
return name_;
}
void CreateAlarmRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int CreateAlarmRequest::getEvaluationCount()const
{
return evaluationCount_;
}
void CreateAlarmRequest::setEvaluationCount(int evaluationCount)
{
evaluationCount_ = evaluationCount;
setParameter("EvaluationCount", std::to_string(evaluationCount));
}
std::string CreateAlarmRequest::getMetricName()const
{
return metricName_;
}
void CreateAlarmRequest::setMetricName(const std::string& metricName)
{
metricName_ = metricName;
setParameter("MetricName", metricName);
}
std::vector<CreateAlarmRequest::Dimension> CreateAlarmRequest::getDimension()const
{
return dimension_;
}
void CreateAlarmRequest::setDimension(const std::vector<Dimension>& dimension)
{
dimension_ = dimension;
int i = 0;
for(int i = 0; i!= dimension.size(); i++) {
auto obj = dimension.at(i);
std::string str ="Dimension."+ std::to_string(i);
setParameter(str + ".DimensionValue", obj.dimensionValue);
setParameter(str + ".DimensionKey", obj.dimensionKey);
}
}
std::string CreateAlarmRequest::getStatistics()const
{
return statistics_;
}
void CreateAlarmRequest::setStatistics(const std::string& statistics)
{
statistics_ = statistics;
setParameter("Statistics", statistics);
}

52
ess/src/model/CreateAlarmResult.cc Executable file
View File

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

6
ess/src/model/CreateLifecycleHookRequest.cc
View File

@@ -158,12 +158,12 @@ void CreateLifecycleHookRequest::setLifecycleHook(const std::vector<LifecycleHoo
for(int i = 0; i!= lifecycleHook.size(); i++) {
auto obj = lifecycleHook.at(i);
std::string str ="LifecycleHook."+ std::to_string(i);
setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
setParameter(str + ".DefaultResult", obj.defaultResult);
setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
setParameter(str + ".NotificationArn", obj.notificationArn);
setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
}
}

239
ess/src/model/CreateScalingConfigurationRequest.cc
View File

@@ -25,17 +25,6 @@ CreateScalingConfigurationRequest::CreateScalingConfigurationRequest() :
CreateScalingConfigurationRequest::~CreateScalingConfigurationRequest()
{}
int CreateScalingConfigurationRequest::getDataDisk3Size()const
{
return dataDisk3Size_;
}
void CreateScalingConfigurationRequest::setDataDisk3Size(int dataDisk3Size)
{
dataDisk3Size_ = dataDisk3Size;
setParameter("DataDisk3Size", std::to_string(dataDisk3Size));
}
std::string CreateScalingConfigurationRequest::getImageId()const
{
return imageId_;
@@ -47,39 +36,6 @@ void CreateScalingConfigurationRequest::setImageId(const std::string& imageId)
setParameter("ImageId", imageId);
}
std::string CreateScalingConfigurationRequest::getDataDisk1SnapshotId()const
{
return dataDisk1SnapshotId_;
}
void CreateScalingConfigurationRequest::setDataDisk1SnapshotId(const std::string& dataDisk1SnapshotId)
{
dataDisk1SnapshotId_ = dataDisk1SnapshotId;
setParameter("DataDisk1SnapshotId", dataDisk1SnapshotId);
}
std::string CreateScalingConfigurationRequest::getDataDisk3Category()const
{
return dataDisk3Category_;
}
void CreateScalingConfigurationRequest::setDataDisk3Category(const std::string& dataDisk3Category)
{
dataDisk3Category_ = dataDisk3Category;
setParameter("DataDisk3Category", dataDisk3Category);
}
std::string CreateScalingConfigurationRequest::getDataDisk1Device()const
{
return dataDisk1Device_;
}
void CreateScalingConfigurationRequest::setDataDisk1Device(const std::string& dataDisk1Device)
{
dataDisk1Device_ = dataDisk1Device;
setParameter("DataDisk1Device", dataDisk1Device);
}
std::string CreateScalingConfigurationRequest::getScalingGroupId()const
{
return scalingGroupId_;
@@ -91,17 +47,6 @@ void CreateScalingConfigurationRequest::setScalingGroupId(const std::string& sca
setParameter("ScalingGroupId", scalingGroupId);
}
std::string CreateScalingConfigurationRequest::getDataDisk2Device()const
{
return dataDisk2Device_;
}
void CreateScalingConfigurationRequest::setDataDisk2Device(const std::string& dataDisk2Device)
{
dataDisk2Device_ = dataDisk2Device;
setParameter("DataDisk2Device", dataDisk2Device);
}
std::vector<std::string> CreateScalingConfigurationRequest::getInstanceTypes()const
{
return instanceTypes_;
@@ -219,17 +164,6 @@ void CreateScalingConfigurationRequest::setUserData(const std::string& userData)
setParameter("UserData", userData);
}
std::string CreateScalingConfigurationRequest::getDataDisk4Category()const
{
return dataDisk4Category_;
}
void CreateScalingConfigurationRequest::setDataDisk4Category(const std::string& dataDisk4Category)
{
dataDisk4Category_ = dataDisk4Category;
setParameter("DataDisk4Category", dataDisk4Category);
}
std::string CreateScalingConfigurationRequest::getHostName()const
{
return hostName_;
@@ -241,17 +175,6 @@ void CreateScalingConfigurationRequest::setHostName(const std::string& hostName)
setParameter("HostName", hostName);
}
std::string CreateScalingConfigurationRequest::getDataDisk2SnapshotId()const
{
return dataDisk2SnapshotId_;
}
void CreateScalingConfigurationRequest::setDataDisk2SnapshotId(const std::string& dataDisk2SnapshotId)
{
dataDisk2SnapshotId_ = dataDisk2SnapshotId;
setParameter("DataDisk2SnapshotId", dataDisk2SnapshotId);
}
bool CreateScalingConfigurationRequest::getPasswordInherit()const
{
return passwordInherit_;
@@ -263,15 +186,15 @@ void CreateScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
setParameter("PasswordInherit", std::to_string(passwordInherit));
}
int CreateScalingConfigurationRequest::getDataDisk4Size()const
std::string CreateScalingConfigurationRequest::getImageName()const
{
return dataDisk4Size_;
return imageName_;
}
void CreateScalingConfigurationRequest::setDataDisk4Size(int dataDisk4Size)
void CreateScalingConfigurationRequest::setImageName(const std::string& imageName)
{
dataDisk4Size_ = dataDisk4Size;
setParameter("DataDisk4Size", std::to_string(dataDisk4Size));
imageName_ = imageName;
setParameter("ImageName", imageName);
}
std::string CreateScalingConfigurationRequest::getInstanceType()const
@@ -285,39 +208,6 @@ void CreateScalingConfigurationRequest::setInstanceType(const std::string& insta
setParameter("InstanceType", instanceType);
}
std::string CreateScalingConfigurationRequest::getDataDisk2Category()const
{
return dataDisk2Category_;
}
void CreateScalingConfigurationRequest::setDataDisk2Category(const std::string& dataDisk2Category)
{
dataDisk2Category_ = dataDisk2Category;
setParameter("DataDisk2Category", dataDisk2Category);
}
int CreateScalingConfigurationRequest::getDataDisk1Size()const
{
return dataDisk1Size_;
}
void CreateScalingConfigurationRequest::setDataDisk1Size(int dataDisk1Size)
{
dataDisk1Size_ = dataDisk1Size;
setParameter("DataDisk1Size", std::to_string(dataDisk1Size));
}
std::string CreateScalingConfigurationRequest::getDataDisk3SnapshotId()const
{
return dataDisk3SnapshotId_;
}
void CreateScalingConfigurationRequest::setDataDisk3SnapshotId(const std::string& dataDisk3SnapshotId)
{
dataDisk3SnapshotId_ = dataDisk3SnapshotId;
setParameter("DataDisk3SnapshotId", dataDisk3SnapshotId);
}
std::string CreateScalingConfigurationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
@@ -340,17 +230,6 @@ void CreateScalingConfigurationRequest::setOwnerAccount(const std::string& owner
setParameter("OwnerAccount", ownerAccount);
}
int CreateScalingConfigurationRequest::getDataDisk2Size()const
{
return dataDisk2Size_;
}
void CreateScalingConfigurationRequest::setDataDisk2Size(int dataDisk2Size)
{
dataDisk2Size_ = dataDisk2Size;
setParameter("DataDisk2Size", std::to_string(dataDisk2Size));
}
std::string CreateScalingConfigurationRequest::getRamRoleName()const
{
return ramRoleName_;
@@ -373,6 +252,26 @@ void CreateScalingConfigurationRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::vector<CreateScalingConfigurationRequest::DataDisk> CreateScalingConfigurationRequest::getDataDisk()const
{
return dataDisk_;
}
void CreateScalingConfigurationRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
{
dataDisk_ = dataDisk;
int i = 0;
for(int i = 0; i!= dataDisk.size(); i++) {
auto obj = dataDisk.at(i);
std::string str ="DataDisk."+ std::to_string(i);
setParameter(str + ".SnapshotId", obj.snapshotId);
setParameter(str + ".Size", std::to_string(obj.size));
setParameter(str + ".Category", obj.category);
setParameter(str + ".Device", obj.device);
setParameter(str + ".DeleteWithInstance", std::to_string(obj.deleteWithInstance));
}
}
std::string CreateScalingConfigurationRequest::getScalingConfigurationName()const
{
return scalingConfigurationName_;
@@ -395,17 +294,6 @@ void CreateScalingConfigurationRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
std::string CreateScalingConfigurationRequest::getDataDisk2DeleteWithInstance()const
{
return dataDisk2DeleteWithInstance_;
}
void CreateScalingConfigurationRequest::setDataDisk2DeleteWithInstance(const std::string& dataDisk2DeleteWithInstance)
{
dataDisk2DeleteWithInstance_ = dataDisk2DeleteWithInstance;
setParameter("DataDisk2DeleteWithInstance", dataDisk2DeleteWithInstance);
}
std::string CreateScalingConfigurationRequest::getSpotStrategy()const
{
return spotStrategy_;
@@ -417,28 +305,6 @@ void CreateScalingConfigurationRequest::setSpotStrategy(const std::string& spotS
setParameter("SpotStrategy", spotStrategy);
}
std::string CreateScalingConfigurationRequest::getDataDisk1Category()const
{
return dataDisk1Category_;
}
void CreateScalingConfigurationRequest::setDataDisk1Category(const std::string& dataDisk1Category)
{
dataDisk1Category_ = dataDisk1Category;
setParameter("DataDisk1Category", dataDisk1Category);
}
std::string CreateScalingConfigurationRequest::getDataDisk3DeleteWithInstance()const
{
return dataDisk3DeleteWithInstance_;
}
void CreateScalingConfigurationRequest::setDataDisk3DeleteWithInstance(const std::string& dataDisk3DeleteWithInstance)
{
dataDisk3DeleteWithInstance_ = dataDisk3DeleteWithInstance;
setParameter("DataDisk3DeleteWithInstance", dataDisk3DeleteWithInstance);
}
int CreateScalingConfigurationRequest::getLoadBalancerWeight()const
{
return loadBalancerWeight_;
@@ -472,28 +338,6 @@ void CreateScalingConfigurationRequest::setSystemDiskSize(int systemDiskSize)
setParameter("SystemDiskSize", std::to_string(systemDiskSize));
}
std::string CreateScalingConfigurationRequest::getDataDisk4SnapshotId()const
{
return dataDisk4SnapshotId_;
}
void CreateScalingConfigurationRequest::setDataDisk4SnapshotId(const std::string& dataDisk4SnapshotId)
{
dataDisk4SnapshotId_ = dataDisk4SnapshotId;
setParameter("DataDisk4SnapshotId", dataDisk4SnapshotId);
}
std::string CreateScalingConfigurationRequest::getDataDisk4Device()const
{
return dataDisk4Device_;
}
void CreateScalingConfigurationRequest::setDataDisk4Device(const std::string& dataDisk4Device)
{
dataDisk4Device_ = dataDisk4Device;
setParameter("DataDisk4Device", dataDisk4Device);
}
std::string CreateScalingConfigurationRequest::getInternetChargeType()const
{
return internetChargeType_;
@@ -505,28 +349,6 @@ void CreateScalingConfigurationRequest::setInternetChargeType(const std::string&
setParameter("InternetChargeType", internetChargeType);
}
std::string CreateScalingConfigurationRequest::getDataDisk3Device()const
{
return dataDisk3Device_;
}
void CreateScalingConfigurationRequest::setDataDisk3Device(const std::string& dataDisk3Device)
{
dataDisk3Device_ = dataDisk3Device;
setParameter("DataDisk3Device", dataDisk3Device);
}
std::string CreateScalingConfigurationRequest::getDataDisk4DeleteWithInstance()const
{
return dataDisk4DeleteWithInstance_;
}
void CreateScalingConfigurationRequest::setDataDisk4DeleteWithInstance(const std::string& dataDisk4DeleteWithInstance)
{
dataDisk4DeleteWithInstance_ = dataDisk4DeleteWithInstance;
setParameter("DataDisk4DeleteWithInstance", dataDisk4DeleteWithInstance);
}
int CreateScalingConfigurationRequest::getInternetMaxBandwidthIn()const
{
return internetMaxBandwidthIn_;
@@ -538,14 +360,3 @@ void CreateScalingConfigurationRequest::setInternetMaxBandwidthIn(int internetMa
setParameter("InternetMaxBandwidthIn", std::to_string(internetMaxBandwidthIn));
}
std::string CreateScalingConfigurationRequest::getDataDisk1DeleteWithInstance()const
{
return dataDisk1DeleteWithInstance_;
}
void CreateScalingConfigurationRequest::setDataDisk1DeleteWithInstance(const std::string& dataDisk1DeleteWithInstance)
{
dataDisk1DeleteWithInstance_ = dataDisk1DeleteWithInstance;
setParameter("DataDisk1DeleteWithInstance", dataDisk1DeleteWithInstance);
}

6
ess/src/model/CreateScalingGroupRequest.cc
View File

@@ -192,12 +192,12 @@ void CreateScalingGroupRequest::setLifecycleHook(const std::vector<LifecycleHook
for(int i = 0; i!= lifecycleHook.size(); i++) {
auto obj = lifecycleHook.at(i);
std::string str ="LifecycleHook."+ std::to_string(i);
setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
setParameter(str + ".DefaultResult", obj.defaultResult);
setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
setParameter(str + ".NotificationArn", obj.notificationArn);
setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
}
}

82
ess/src/model/DeleteAlarmRequest.cc Executable file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/DeleteAlarmRequest.h>
using AlibabaCloud::Ess::Model::DeleteAlarmRequest;
DeleteAlarmRequest::DeleteAlarmRequest() :
RpcServiceRequest("ess", "2014-08-28", "DeleteAlarm")
{}
DeleteAlarmRequest::~DeleteAlarmRequest()
{}
std::string DeleteAlarmRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteAlarmRequest::getRegionId()const
{
return regionId_;
}
void DeleteAlarmRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
long DeleteAlarmRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteAlarmRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteAlarmRequest::getAlarmTaskId()const
{
return alarmTaskId_;
}
void DeleteAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
{
alarmTaskId_ = alarmTaskId;
setParameter("AlarmTaskId", alarmTaskId);
}
std::string DeleteAlarmRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

52
ess/src/model/DeleteAlarmResult.cc Executable file
View File

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

148
ess/src/model/DescribeAlarmsRequest.cc Executable file
View File

@@ -0,0 +1,148 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/DescribeAlarmsRequest.h>
using AlibabaCloud::Ess::Model::DescribeAlarmsRequest;
DescribeAlarmsRequest::DescribeAlarmsRequest() :
RpcServiceRequest("ess", "2014-08-28", "DescribeAlarms")
{}
DescribeAlarmsRequest::~DescribeAlarmsRequest()
{}
bool DescribeAlarmsRequest::getIsEnable()const
{
return isEnable_;
}
void DescribeAlarmsRequest::setIsEnable(bool isEnable)
{
isEnable_ = isEnable;
setParameter("IsEnable", std::to_string(isEnable));
}
std::string DescribeAlarmsRequest::getMetricType()const
{
return metricType_;
}
void DescribeAlarmsRequest::setMetricType(const std::string& metricType)
{
metricType_ = metricType;
setParameter("MetricType", metricType);
}
std::string DescribeAlarmsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAlarmsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeAlarmsRequest::getRegionId()const
{
return regionId_;
}
void DescribeAlarmsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeAlarmsRequest::getScalingGroupId()const
{
return scalingGroupId_;
}
void DescribeAlarmsRequest::setScalingGroupId(const std::string& scalingGroupId)
{
scalingGroupId_ = scalingGroupId;
setParameter("ScalingGroupId", scalingGroupId);
}
int DescribeAlarmsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeAlarmsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeAlarmsRequest::getState()const
{
return state_;
}
void DescribeAlarmsRequest::setState(const std::string& state)
{
state_ = state;
setParameter("State", state);
}
long DescribeAlarmsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAlarmsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAlarmsRequest::getAlarmTaskId()const
{
return alarmTaskId_;
}
void DescribeAlarmsRequest::setAlarmTaskId(const std::string& alarmTaskId)
{
alarmTaskId_ = alarmTaskId;
setParameter("AlarmTaskId", alarmTaskId);
}
int DescribeAlarmsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeAlarmsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeAlarmsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAlarmsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

108
ess/src/model/DescribeAlarmsResult.cc Executable file
View File

@@ -0,0 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/DescribeAlarmsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ess;
using namespace AlibabaCloud::Ess::Model;
DescribeAlarmsResult::DescribeAlarmsResult() :
ServiceResult()
{}
DescribeAlarmsResult::DescribeAlarmsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeAlarmsResult::~DescribeAlarmsResult()
{}
void DescribeAlarmsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAlarmList = value["AlarmList"]["Alarm"];
for (auto value : allAlarmList)
{
Alarm alarmListObject;
if(!value["AlarmTaskId"].isNull())
alarmListObject.alarmTaskId = value["AlarmTaskId"].asString();
if(!value["Name"].isNull())
alarmListObject.name = value["Name"].asString();
if(!value["Description"].isNull())
alarmListObject.description = value["Description"].asString();
if(!value["MetricType"].isNull())
alarmListObject.metricType = value["MetricType"].asString();
if(!value["MetricName"].isNull())
alarmListObject.metricName = value["MetricName"].asString();
if(!value["Dimensions"].isNull())
alarmListObject.dimensions = value["Dimensions"].asString();
if(!value["Period"].isNull())
alarmListObject.period = std::stoi(value["Period"].asString());
if(!value["Statistics"].isNull())
alarmListObject.statistics = value["Statistics"].asString();
if(!value["ComparisonOperator"].isNull())
alarmListObject.comparisonOperator = value["ComparisonOperator"].asString();
if(!value["Threshold"].isNull())
alarmListObject.threshold = std::stof(value["Threshold"].asString());
if(!value["EvaluationCount"].isNull())
alarmListObject.evaluationCount = std::stoi(value["EvaluationCount"].asString());
if(!value["State"].isNull())
alarmListObject.state = value["State"].asString();
if(!value["ScalingGroupId"].isNull())
alarmListObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["Enable"].isNull())
alarmListObject.enable = value["Enable"].asString() == "true";
auto allAlarmActions = value["alarmActions"]["alarmAction"];
for (auto value : allAlarmActions)
alarmListObject.alarmActions.push_back(value.asString());
alarmList_.push_back(alarmListObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
}
int DescribeAlarmsResult::getTotalCount()const
{
return totalCount_;
}
int DescribeAlarmsResult::getPageSize()const
{
return pageSize_;
}
int DescribeAlarmsResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeAlarmsResult::Alarm> DescribeAlarmsResult::getAlarmList()const
{
return alarmList_;
}

4
ess/src/model/DescribeScalingConfigurationsResult.cc
View File

@@ -54,6 +54,8 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
scalingConfigurationsObject.instanceName = value["InstanceName"].asString();
if(!value["ImageId"].isNull())
scalingConfigurationsObject.imageId = value["ImageId"].asString();
if(!value["ImageName"].isNull())
scalingConfigurationsObject.imageName = value["ImageName"].asString();
if(!value["HostName"].isNull())
scalingConfigurationsObject.hostName = value["HostName"].asString();
if(!value["InstanceType"].isNull())
@@ -106,6 +108,8 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
dataDisksObject.snapshotId = value["SnapshotId"].asString();
if(!value["Device"].isNull())
dataDisksObject.device = value["Device"].asString();
if(!value["DeleteWithInstance"].isNull())
dataDisksObject.deleteWithInstance = value["DeleteWithInstance"].asString() == "true";
scalingConfigurationsObject.dataDisks.push_back(dataDisksObject);
}
auto allTags = value["Tags"]["Tag"];

82
ess/src/model/DisableAlarmRequest.cc Executable file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/DisableAlarmRequest.h>
using AlibabaCloud::Ess::Model::DisableAlarmRequest;
DisableAlarmRequest::DisableAlarmRequest() :
RpcServiceRequest("ess", "2014-08-28", "DisableAlarm")
{}
DisableAlarmRequest::~DisableAlarmRequest()
{}
std::string DisableAlarmRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DisableAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DisableAlarmRequest::getRegionId()const
{
return regionId_;
}
void DisableAlarmRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
long DisableAlarmRequest::getOwnerId()const
{
return ownerId_;
}
void DisableAlarmRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DisableAlarmRequest::getAlarmTaskId()const
{
return alarmTaskId_;
}
void DisableAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
{
alarmTaskId_ = alarmTaskId;
setParameter("AlarmTaskId", alarmTaskId);
}
std::string DisableAlarmRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DisableAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

45
ess/src/model/DisableAlarmResult.cc Executable file
View File

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

82
ess/src/model/EnableAlarmRequest.cc Executable file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/EnableAlarmRequest.h>
using AlibabaCloud::Ess::Model::EnableAlarmRequest;
EnableAlarmRequest::EnableAlarmRequest() :
RpcServiceRequest("ess", "2014-08-28", "EnableAlarm")
{}
EnableAlarmRequest::~EnableAlarmRequest()
{}
std::string EnableAlarmRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void EnableAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string EnableAlarmRequest::getRegionId()const
{
return regionId_;
}
void EnableAlarmRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
long EnableAlarmRequest::getOwnerId()const
{
return ownerId_;
}
void EnableAlarmRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string EnableAlarmRequest::getAlarmTaskId()const
{
return alarmTaskId_;
}
void EnableAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
{
alarmTaskId_ = alarmTaskId;
setParameter("AlarmTaskId", alarmTaskId);
}
std::string EnableAlarmRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void EnableAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

45
ess/src/model/EnableAlarmResult.cc Executable file
View File

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

116
ess/src/model/ModifyAlarmRequest.cc Executable file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ess/model/ModifyAlarmRequest.h>
using AlibabaCloud::Ess::Model::ModifyAlarmRequest;
ModifyAlarmRequest::ModifyAlarmRequest() :
RpcServiceRequest("ess", "2014-08-28", "ModifyAlarm")
{}
ModifyAlarmRequest::~ModifyAlarmRequest()
{}
std::string ModifyAlarmRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifyAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyAlarmRequest::getRegionId()const
{
return regionId_;
}
void ModifyAlarmRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyAlarmRequest::getName()const
{
return name_;
}
void ModifyAlarmRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string ModifyAlarmRequest::getDescription()const
{
return description_;
}
void ModifyAlarmRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::vector<std::string> ModifyAlarmRequest::getAlarmAction()const
{
return alarmAction_;
}
void ModifyAlarmRequest::setAlarmAction(const std::vector<std::string>& alarmAction)
{
alarmAction_ = alarmAction;
for(int i = 0; i!= alarmAction.size(); i++)
setParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
}
long ModifyAlarmRequest::getOwnerId()const
{
return ownerId_;
}
void ModifyAlarmRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyAlarmRequest::getAlarmTaskId()const
{
return alarmTaskId_;
}
void ModifyAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
{
alarmTaskId_ = alarmTaskId;
setParameter("AlarmTaskId", alarmTaskId);
}
std::string ModifyAlarmRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

52
ess/src/model/ModifyAlarmResult.cc Executable file
View File

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

188
ess/src/model/ModifyScalingConfigurationRequest.cc
View File

@@ -36,26 +36,15 @@ void ModifyScalingConfigurationRequest::setImageId(const std::string& imageId)
setParameter("ImageId", imageId);
}
std::string ModifyScalingConfigurationRequest::getResourceOwnerAccount()const
std::string ModifyScalingConfigurationRequest::getIoOptimized()const
{
return resourceOwnerAccount_;
return ioOptimized_;
}
void ModifyScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
void ModifyScalingConfigurationRequest::setIoOptimized(const std::string& ioOptimized)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyScalingConfigurationRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ModifyScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
ioOptimized_ = ioOptimized;
setParameter("IoOptimized", ioOptimized);
}
std::vector<std::string> ModifyScalingConfigurationRequest::getInstanceTypes()const
@@ -81,17 +70,6 @@ void ModifyScalingConfigurationRequest::setInternetMaxBandwidthOut(int internetM
setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
}
std::string ModifyScalingConfigurationRequest::getRamRoleName()const
{
return ramRoleName_;
}
void ModifyScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
{
ramRoleName_ = ramRoleName;
setParameter("RamRoleName", ramRoleName);
}
std::string ModifyScalingConfigurationRequest::getKeyPairName()const
{
return keyPairName_;
@@ -103,15 +81,21 @@ void ModifyScalingConfigurationRequest::setKeyPairName(const std::string& keyPai
setParameter("KeyPairName", keyPairName);
}
long ModifyScalingConfigurationRequest::getOwnerId()const
std::vector<ModifyScalingConfigurationRequest::SpotPriceLimit> ModifyScalingConfigurationRequest::getSpotPriceLimit()const
{
return ownerId_;
return spotPriceLimit_;
}
void ModifyScalingConfigurationRequest::setOwnerId(long ownerId)
void ModifyScalingConfigurationRequest::setSpotPriceLimit(const std::vector<SpotPriceLimit>& spotPriceLimit)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
spotPriceLimit_ = spotPriceLimit;
int i = 0;
for(int i = 0; i!= spotPriceLimit.size(); i++) {
auto obj = spotPriceLimit.at(i);
std::string str ="SpotPriceLimit."+ std::to_string(i);
setParameter(str + ".InstanceType", obj.instanceType);
setParameter(str + ".PriceLimit", std::to_string(obj.priceLimit));
}
}
std::string ModifyScalingConfigurationRequest::getSystemDiskCategory()const
@@ -136,6 +120,114 @@ void ModifyScalingConfigurationRequest::setAccessKeyId(const std::string& access
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyScalingConfigurationRequest::getUserData()const
{
return userData_;
}
void ModifyScalingConfigurationRequest::setUserData(const std::string& userData)
{
userData_ = userData;
setParameter("UserData", userData);
}
std::string ModifyScalingConfigurationRequest::getHostName()const
{
return hostName_;
}
void ModifyScalingConfigurationRequest::setHostName(const std::string& hostName)
{
hostName_ = hostName;
setParameter("HostName", hostName);
}
bool ModifyScalingConfigurationRequest::getPasswordInherit()const
{
return passwordInherit_;
}
void ModifyScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
{
passwordInherit_ = passwordInherit;
setParameter("PasswordInherit", std::to_string(passwordInherit));
}
std::string ModifyScalingConfigurationRequest::getImageName()const
{
return imageName_;
}
void ModifyScalingConfigurationRequest::setImageName(const std::string& imageName)
{
imageName_ = imageName;
setParameter("ImageName", imageName);
}
std::string ModifyScalingConfigurationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifyScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyScalingConfigurationRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ModifyScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string ModifyScalingConfigurationRequest::getRamRoleName()const
{
return ramRoleName_;
}
void ModifyScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
{
ramRoleName_ = ramRoleName;
setParameter("RamRoleName", ramRoleName);
}
long ModifyScalingConfigurationRequest::getOwnerId()const
{
return ownerId_;
}
void ModifyScalingConfigurationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::vector<ModifyScalingConfigurationRequest::DataDisk> ModifyScalingConfigurationRequest::getDataDisk()const
{
return dataDisk_;
}
void ModifyScalingConfigurationRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
{
dataDisk_ = dataDisk;
int i = 0;
for(int i = 0; i!= dataDisk.size(); i++) {
auto obj = dataDisk.at(i);
std::string str ="DataDisk."+ std::to_string(i);
setParameter(str + ".SnapshotId", obj.snapshotId);
setParameter(str + ".Size", std::to_string(obj.size));
setParameter(str + ".Category", obj.category);
setParameter(str + ".Device", obj.device);
setParameter(str + ".DeleteWithInstance", std::to_string(obj.deleteWithInstance));
}
}
std::string ModifyScalingConfigurationRequest::getScalingConfigurationName()const
{
return scalingConfigurationName_;
@@ -169,26 +261,15 @@ void ModifyScalingConfigurationRequest::setScalingConfigurationId(const std::str
setParameter("ScalingConfigurationId", scalingConfigurationId);
}
std::string ModifyScalingConfigurationRequest::getUserData()const
std::string ModifyScalingConfigurationRequest::getSpotStrategy()const
{
return userData_;
return spotStrategy_;
}
void ModifyScalingConfigurationRequest::setUserData(const std::string& userData)
void ModifyScalingConfigurationRequest::setSpotStrategy(const std::string& spotStrategy)
{
userData_ = userData;
setParameter("UserData", userData);
}
std::string ModifyScalingConfigurationRequest::getHostName()const
{
return hostName_;
}
void ModifyScalingConfigurationRequest::setHostName(const std::string& hostName)
{
hostName_ = hostName;
setParameter("HostName", hostName);
spotStrategy_ = spotStrategy;
setParameter("SpotStrategy", spotStrategy);
}
std::string ModifyScalingConfigurationRequest::getInstanceName()const
@@ -213,17 +294,6 @@ void ModifyScalingConfigurationRequest::setLoadBalancerWeight(int loadBalancerWe
setParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
}
bool ModifyScalingConfigurationRequest::getPasswordInherit()const
{
return passwordInherit_;
}
void ModifyScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
{
passwordInherit_ = passwordInherit;
setParameter("PasswordInherit", std::to_string(passwordInherit));
}
int ModifyScalingConfigurationRequest::getSystemDiskSize()const
{
return systemDiskSize_;