diff --git a/CHANGELOG b/CHANGELOG index e2c6f4d72..480644698 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,7 @@ +2018-08-16 Version: 1.22.5 +1, ModifyScalingConfiguration add imageName. +2, CreateScalingConfiguration add imageName. + 2018-08-15 Version: 1.22.4 1, Fix bug in GetMaterials API. 2, GetVerifyToken added a new param VerifyConfigs diff --git a/VERSION b/VERSION index be02b337a..054c858fb 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.22.4 \ No newline at end of file +1.22.5 \ No newline at end of file diff --git a/ess/.DS_Store b/ess/.DS_Store deleted file mode 100644 index e0d9c9ed1..000000000 Binary files a/ess/.DS_Store and /dev/null differ diff --git a/ess/CMakeLists.txt b/ess/CMakeLists.txt index aec7c7bad..d2a89bb19 100755 --- a/ess/CMakeLists.txt +++ b/ess/CMakeLists.txt @@ -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 ) diff --git a/ess/include/.DS_Store b/ess/include/.DS_Store deleted file mode 100644 index 28ea85658..000000000 Binary files a/ess/include/.DS_Store and /dev/null differ diff --git a/ess/include/alibabacloud/.DS_Store b/ess/include/alibabacloud/.DS_Store deleted file mode 100644 index 26738532b..000000000 Binary files a/ess/include/alibabacloud/.DS_Store and /dev/null differ diff --git a/ess/include/alibabacloud/ess/.DS_Store b/ess/include/alibabacloud/ess/.DS_Store deleted file mode 100644 index ee7d3e968..000000000 Binary files a/ess/include/alibabacloud/ess/.DS_Store and /dev/null differ diff --git a/ess/include/alibabacloud/ess/EssClient.h b/ess/include/alibabacloud/ess/EssClient.h index 515d3f80f..d6c6d8cf0 100755 --- a/ess/include/alibabacloud/ess/EssClient.h +++ b/ess/include/alibabacloud/ess/EssClient.h @@ -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 DescribeLifecycleHooksOutcome; typedef std::future DescribeLifecycleHooksOutcomeCallable; typedef std::function&)> DescribeLifecycleHooksAsyncHandler; + typedef Outcome ModifyAlarmOutcome; + typedef std::future ModifyAlarmOutcomeCallable; + typedef std::function&)> ModifyAlarmAsyncHandler; typedef Outcome DescribeAccountAttributesOutcome; typedef std::future DescribeAccountAttributesOutcomeCallable; typedef std::function&)> DescribeAccountAttributesAsyncHandler; + typedef Outcome DeleteAlarmOutcome; + typedef std::future DeleteAlarmOutcomeCallable; + typedef std::function&)> DeleteAlarmAsyncHandler; typedef Outcome DescribeScalingActivityDetailOutcome; typedef std::future DescribeScalingActivityDetailOutcomeCallable; typedef std::function&)> DescribeScalingActivityDetailAsyncHandler; + typedef Outcome DisableAlarmOutcome; + typedef std::future DisableAlarmOutcomeCallable; + typedef std::function&)> DisableAlarmAsyncHandler; typedef Outcome VerifyUserOutcome; typedef std::future VerifyUserOutcomeCallable; typedef std::function&)> VerifyUserAsyncHandler; + typedef Outcome DescribeAlarmsOutcome; + typedef std::future DescribeAlarmsOutcomeCallable; + typedef std::function&)> DescribeAlarmsAsyncHandler; typedef Outcome AttachInstancesOutcome; typedef std::future AttachInstancesOutcomeCallable; typedef std::function&)> AttachInstancesAsyncHandler; @@ -224,6 +248,9 @@ namespace AlibabaCloud typedef Outcome DescribeScalingRulesOutcome; typedef std::future DescribeScalingRulesOutcomeCallable; typedef std::function&)> DescribeScalingRulesAsyncHandler; + typedef Outcome CreateAlarmOutcome; + typedef std::future CreateAlarmOutcomeCallable; + typedef std::function&)> CreateAlarmAsyncHandler; typedef Outcome EnableScalingGroupOutcome; typedef std::future EnableScalingGroupOutcomeCallable; typedef std::function&)> EnableScalingGroupAsyncHandler; @@ -293,6 +320,9 @@ namespace AlibabaCloud typedef Outcome CreateLifecycleHookOutcome; typedef std::future CreateLifecycleHookOutcomeCallable; typedef std::function&)> CreateLifecycleHookAsyncHandler; + typedef Outcome EnableAlarmOutcome; + typedef std::future EnableAlarmOutcomeCallable; + typedef std::function&)> EnableAlarmAsyncHandler; typedef Outcome ModifyAlertConfigOutcome; typedef std::future ModifyAlertConfigOutcomeCallable; typedef std::function&)> 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; ModifyAlertConfigOutcomeCallable modifyAlertConfigCallable(const Model::ModifyAlertConfigRequest& request) const; diff --git a/ess/include/alibabacloud/ess/model/CreateAlarmRequest.h b/ess/include/alibabacloud/ess/model/CreateAlarmRequest.h new file mode 100755 index 000000000..5f263c871 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/CreateAlarmRequest.h @@ -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 +#include +#include +#include + +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 getAlarmAction()const; + void setAlarmAction(const std::vector& 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 getDimension()const; + void setDimension(const std::vector& 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 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_; + std::string statistics_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/CreateAlarmResult.h b/ess/include/alibabacloud/ess/model/CreateAlarmResult.h new file mode 100755 index 000000000..663098b0d --- /dev/null +++ b/ess/include/alibabacloud/ess/model/CreateAlarmResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/CreateLifecycleHookRequest.h b/ess/include/alibabacloud/ess/model/CreateLifecycleHookRequest.h index c55aa667d..531f65123 100755 --- a/ess/include/alibabacloud/ess/model/CreateLifecycleHookRequest.h +++ b/ess/include/alibabacloud/ess/model/CreateLifecycleHookRequest.h @@ -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: diff --git a/ess/include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h b/ess/include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h index e80a19317..b7320ded6 100755 --- a/ess/include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h +++ b/ess/include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h @@ -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 getInstanceTypes()const; void setInstanceTypes(const std::vector& 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 getDataDisk()const; + void setDataDisk(const std::vector& 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 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_; 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_; }; } diff --git a/ess/include/alibabacloud/ess/model/CreateScalingGroupRequest.h b/ess/include/alibabacloud/ess/model/CreateScalingGroupRequest.h index 514a5d319..13059b1db 100755 --- a/ess/include/alibabacloud/ess/model/CreateScalingGroupRequest.h +++ b/ess/include/alibabacloud/ess/model/CreateScalingGroupRequest.h @@ -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: diff --git a/ess/include/alibabacloud/ess/model/DeleteAlarmRequest.h b/ess/include/alibabacloud/ess/model/DeleteAlarmRequest.h new file mode 100755 index 000000000..fe3b32fd8 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/DeleteAlarmRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/DeleteAlarmResult.h b/ess/include/alibabacloud/ess/model/DeleteAlarmResult.h new file mode 100755 index 000000000..8232d72db --- /dev/null +++ b/ess/include/alibabacloud/ess/model/DeleteAlarmResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/DescribeAlarmsRequest.h b/ess/include/alibabacloud/ess/model/DescribeAlarmsRequest.h new file mode 100755 index 000000000..f0ebe61b5 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/DescribeAlarmsRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/DescribeAlarmsResult.h b/ess/include/alibabacloud/ess/model/DescribeAlarmsResult.h new file mode 100755 index 000000000..5fb01d02f --- /dev/null +++ b/ess/include/alibabacloud/ess/model/DescribeAlarmsResult.h @@ -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 +#include +#include +#include +#include + +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 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 getAlarmList()const; + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + int pageSize_; + int pageNumber_; + std::vector alarmList_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSRESULT_H_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h b/ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h index 9e41c8bb6..96d994497 100755 --- a/ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h +++ b/ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h @@ -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; diff --git a/ess/include/alibabacloud/ess/model/DisableAlarmRequest.h b/ess/include/alibabacloud/ess/model/DisableAlarmRequest.h new file mode 100755 index 000000000..cdc54c363 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/DisableAlarmRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/DisableAlarmResult.h b/ess/include/alibabacloud/ess/model/DisableAlarmResult.h new file mode 100755 index 000000000..cdaf27d99 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/DisableAlarmResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/EnableAlarmRequest.h b/ess/include/alibabacloud/ess/model/EnableAlarmRequest.h new file mode 100755 index 000000000..0d683a408 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/EnableAlarmRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/EnableAlarmResult.h b/ess/include/alibabacloud/ess/model/EnableAlarmResult.h new file mode 100755 index 000000000..2395d0465 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/EnableAlarmResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/ModifyAlarmRequest.h b/ess/include/alibabacloud/ess/model/ModifyAlarmRequest.h new file mode 100755 index 000000000..33f1c7a4e --- /dev/null +++ b/ess/include/alibabacloud/ess/model/ModifyAlarmRequest.h @@ -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 +#include +#include +#include + +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 getAlarmAction()const; + void setAlarmAction(const std::vector& 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 alarmAction_; + long ownerId_; + std::string alarmTaskId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/ModifyAlarmResult.h b/ess/include/alibabacloud/ess/model/ModifyAlarmResult.h new file mode 100755 index 000000000..24d07e3e4 --- /dev/null +++ b/ess/include/alibabacloud/ess/model/ModifyAlarmResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/ess/include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h b/ess/include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h index a1dc4e582..a50a7cd61 100755 --- a/ess/include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h +++ b/ess/include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h @@ -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 getInstanceTypes()const; void setInstanceTypes(const std::vector& 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 getSpotPriceLimit()const; + void setSpotPriceLimit(const std::vector& 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 getDataDisk()const; + void setDataDisk(const std::vector& 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 instanceTypes_; int internetMaxBandwidthOut_; - std::string ramRoleName_; std::string keyPairName_; - long ownerId_; + std::vector 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_; 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_; diff --git a/ess/src/.DS_Store b/ess/src/.DS_Store deleted file mode 100644 index 9a9388cba..000000000 Binary files a/ess/src/.DS_Store and /dev/null differ diff --git a/ess/src/EssClient.cc b/ess/src/EssClient.cc index 220c82536..2c0c66493 100755 --- a/ess/src/EssClient.cc +++ b/ess/src/EssClient.cc @@ -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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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(); diff --git a/ess/src/model/CreateAlarmRequest.cc b/ess/src/model/CreateAlarmRequest.cc new file mode 100755 index 000000000..f9c2d9a8d --- /dev/null +++ b/ess/src/model/CreateAlarmRequest.cc @@ -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 + +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 CreateAlarmRequest::getAlarmAction()const +{ + return alarmAction_; +} + +void CreateAlarmRequest::setAlarmAction(const std::vector& 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::getDimension()const +{ + return dimension_; +} + +void CreateAlarmRequest::setDimension(const std::vector& 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); +} + diff --git a/ess/src/model/CreateAlarmResult.cc b/ess/src/model/CreateAlarmResult.cc new file mode 100755 index 000000000..d33c1a937 --- /dev/null +++ b/ess/src/model/CreateAlarmResult.cc @@ -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 +#include + +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_; +} + diff --git a/ess/src/model/CreateLifecycleHookRequest.cc b/ess/src/model/CreateLifecycleHookRequest.cc index e4d09bc01..ceb552202 100755 --- a/ess/src/model/CreateLifecycleHookRequest.cc +++ b/ess/src/model/CreateLifecycleHookRequest.cc @@ -158,12 +158,12 @@ void CreateLifecycleHookRequest::setLifecycleHook(const std::vector 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::getDataDisk()const +{ + return dataDisk_; +} + +void CreateScalingConfigurationRequest::setDataDisk(const std::vector& 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); -} - diff --git a/ess/src/model/CreateScalingGroupRequest.cc b/ess/src/model/CreateScalingGroupRequest.cc index 5ef5c9b98..a4dfe0426 100755 --- a/ess/src/model/CreateScalingGroupRequest.cc +++ b/ess/src/model/CreateScalingGroupRequest.cc @@ -192,12 +192,12 @@ void CreateScalingGroupRequest::setLifecycleHook(const std::vector + +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); +} + diff --git a/ess/src/model/DeleteAlarmResult.cc b/ess/src/model/DeleteAlarmResult.cc new file mode 100755 index 000000000..c86d8b8c4 --- /dev/null +++ b/ess/src/model/DeleteAlarmResult.cc @@ -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 +#include + +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_; +} + diff --git a/ess/src/model/DescribeAlarmsRequest.cc b/ess/src/model/DescribeAlarmsRequest.cc new file mode 100755 index 000000000..e175fe59c --- /dev/null +++ b/ess/src/model/DescribeAlarmsRequest.cc @@ -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 + +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); +} + diff --git a/ess/src/model/DescribeAlarmsResult.cc b/ess/src/model/DescribeAlarmsResult.cc new file mode 100755 index 000000000..d0477a5ff --- /dev/null +++ b/ess/src/model/DescribeAlarmsResult.cc @@ -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 +#include + +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::getAlarmList()const +{ + return alarmList_; +} + diff --git a/ess/src/model/DescribeScalingConfigurationsResult.cc b/ess/src/model/DescribeScalingConfigurationsResult.cc index 36af54ece..d95c5c8ba 100755 --- a/ess/src/model/DescribeScalingConfigurationsResult.cc +++ b/ess/src/model/DescribeScalingConfigurationsResult.cc @@ -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"]; diff --git a/ess/src/model/DisableAlarmRequest.cc b/ess/src/model/DisableAlarmRequest.cc new file mode 100755 index 000000000..262c3c5b8 --- /dev/null +++ b/ess/src/model/DisableAlarmRequest.cc @@ -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 + +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); +} + diff --git a/ess/src/model/DisableAlarmResult.cc b/ess/src/model/DisableAlarmResult.cc new file mode 100755 index 000000000..bbf980358 --- /dev/null +++ b/ess/src/model/DisableAlarmResult.cc @@ -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 +#include + +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()); + +} + diff --git a/ess/src/model/EnableAlarmRequest.cc b/ess/src/model/EnableAlarmRequest.cc new file mode 100755 index 000000000..cc874fbba --- /dev/null +++ b/ess/src/model/EnableAlarmRequest.cc @@ -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 + +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); +} + diff --git a/ess/src/model/EnableAlarmResult.cc b/ess/src/model/EnableAlarmResult.cc new file mode 100755 index 000000000..1714d54ab --- /dev/null +++ b/ess/src/model/EnableAlarmResult.cc @@ -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 +#include + +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()); + +} + diff --git a/ess/src/model/ModifyAlarmRequest.cc b/ess/src/model/ModifyAlarmRequest.cc new file mode 100755 index 000000000..ba9fd6b16 --- /dev/null +++ b/ess/src/model/ModifyAlarmRequest.cc @@ -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 + +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 ModifyAlarmRequest::getAlarmAction()const +{ + return alarmAction_; +} + +void ModifyAlarmRequest::setAlarmAction(const std::vector& 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); +} + diff --git a/ess/src/model/ModifyAlarmResult.cc b/ess/src/model/ModifyAlarmResult.cc new file mode 100755 index 000000000..5bf239283 --- /dev/null +++ b/ess/src/model/ModifyAlarmResult.cc @@ -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 +#include + +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_; +} + diff --git a/ess/src/model/ModifyScalingConfigurationRequest.cc b/ess/src/model/ModifyScalingConfigurationRequest.cc index 1b9349f3b..4e3bdbf3e 100755 --- a/ess/src/model/ModifyScalingConfigurationRequest.cc +++ b/ess/src/model/ModifyScalingConfigurationRequest.cc @@ -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 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::getSpotPriceLimit()const { - return ownerId_; + return spotPriceLimit_; } -void ModifyScalingConfigurationRequest::setOwnerId(long ownerId) +void ModifyScalingConfigurationRequest::setSpotPriceLimit(const std::vector& 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::getDataDisk()const +{ + return dataDisk_; +} + +void ModifyScalingConfigurationRequest::setDataDisk(const std::vector& 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_;