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

fixed #51

Browse Source
This commit is contained in:
wb-hx510875
2019-09-19 11:14:07 +08:00
parent 2f6036b803
commit ba463ae2dc
1795 changed files with 41555 additions and 38367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
ess/src/model/DescribeCapacityHistoryResult.cc
View File

@@ -39,20 +39,20 @@ void DescribeCapacityHistoryResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCapacityHistoryItems = value["CapacityHistoryItems"]["CapacityHistoryModel"];
for (auto value : allCapacityHistoryItems)
auto allCapacityHistoryItemsNode = value["CapacityHistoryItems"]["CapacityHistoryModel"];
for (auto valueCapacityHistoryItemsCapacityHistoryModel : allCapacityHistoryItemsNode)
{
CapacityHistoryModel capacityHistoryItemsObject;
if(!value["ScalingGroupId"].isNull())
capacityHistoryItemsObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["TotalCapacity"].isNull())
capacityHistoryItemsObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
if(!value["AttachedCapacity"].isNull())
capacityHistoryItemsObject.attachedCapacity = std::stoi(value["AttachedCapacity"].asString());
if(!value["AutoCreatedCapacity"].isNull())
capacityHistoryItemsObject.autoCreatedCapacity = std::stoi(value["AutoCreatedCapacity"].asString());
if(!value["Timestamp"].isNull())
capacityHistoryItemsObject.timestamp = value["Timestamp"].asString();
if(!valueCapacityHistoryItemsCapacityHistoryModel["ScalingGroupId"].isNull())
capacityHistoryItemsObject.scalingGroupId = valueCapacityHistoryItemsCapacityHistoryModel["ScalingGroupId"].asString();
if(!valueCapacityHistoryItemsCapacityHistoryModel["TotalCapacity"].isNull())
capacityHistoryItemsObject.totalCapacity = std::stoi(valueCapacityHistoryItemsCapacityHistoryModel["TotalCapacity"].asString());
if(!valueCapacityHistoryItemsCapacityHistoryModel["AttachedCapacity"].isNull())
capacityHistoryItemsObject.attachedCapacity = std::stoi(valueCapacityHistoryItemsCapacityHistoryModel["AttachedCapacity"].asString());
if(!valueCapacityHistoryItemsCapacityHistoryModel["AutoCreatedCapacity"].isNull())
capacityHistoryItemsObject.autoCreatedCapacity = std::stoi(valueCapacityHistoryItemsCapacityHistoryModel["AutoCreatedCapacity"].asString());
if(!valueCapacityHistoryItemsCapacityHistoryModel["Timestamp"].isNull())
capacityHistoryItemsObject.timestamp = valueCapacityHistoryItemsCapacityHistoryModel["Timestamp"].asString();
capacityHistoryItems_.push_back(capacityHistoryItemsObject);
}
if(!value["TotalCount"].isNull())

36
ess/src/model/DescribeLifecycleHooksResult.cc
View File

@@ -39,26 +39,26 @@ void DescribeLifecycleHooksResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allLifecycleHooks = value["LifecycleHooks"]["LifecycleHook"];
for (auto value : allLifecycleHooks)
auto allLifecycleHooksNode = value["LifecycleHooks"]["LifecycleHook"];
for (auto valueLifecycleHooksLifecycleHook : allLifecycleHooksNode)
{
LifecycleHook lifecycleHooksObject;
if(!value["ScalingGroupId"].isNull())
lifecycleHooksObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["LifecycleHookId"].isNull())
lifecycleHooksObject.lifecycleHookId = value["LifecycleHookId"].asString();
if(!value["LifecycleHookName"].isNull())
lifecycleHooksObject.lifecycleHookName = value["LifecycleHookName"].asString();
if(!value["DefaultResult"].isNull())
lifecycleHooksObject.defaultResult = value["DefaultResult"].asString();
if(!value["HeartbeatTimeout"].isNull())
lifecycleHooksObject.heartbeatTimeout = std::stoi(value["HeartbeatTimeout"].asString());
if(!value["LifecycleTransition"].isNull())
lifecycleHooksObject.lifecycleTransition = value["LifecycleTransition"].asString();
if(!value["NotificationMetadata"].isNull())
lifecycleHooksObject.notificationMetadata = value["NotificationMetadata"].asString();
if(!value["NotificationArn"].isNull())
lifecycleHooksObject.notificationArn = value["NotificationArn"].asString();
if(!valueLifecycleHooksLifecycleHook["ScalingGroupId"].isNull())
lifecycleHooksObject.scalingGroupId = valueLifecycleHooksLifecycleHook["ScalingGroupId"].asString();
if(!valueLifecycleHooksLifecycleHook["LifecycleHookId"].isNull())
lifecycleHooksObject.lifecycleHookId = valueLifecycleHooksLifecycleHook["LifecycleHookId"].asString();
if(!valueLifecycleHooksLifecycleHook["LifecycleHookName"].isNull())
lifecycleHooksObject.lifecycleHookName = valueLifecycleHooksLifecycleHook["LifecycleHookName"].asString();
if(!valueLifecycleHooksLifecycleHook["DefaultResult"].isNull())
lifecycleHooksObject.defaultResult = valueLifecycleHooksLifecycleHook["DefaultResult"].asString();
if(!valueLifecycleHooksLifecycleHook["HeartbeatTimeout"].isNull())
lifecycleHooksObject.heartbeatTimeout = std::stoi(valueLifecycleHooksLifecycleHook["HeartbeatTimeout"].asString());
if(!valueLifecycleHooksLifecycleHook["LifecycleTransition"].isNull())
lifecycleHooksObject.lifecycleTransition = valueLifecycleHooksLifecycleHook["LifecycleTransition"].asString();
if(!valueLifecycleHooksLifecycleHook["NotificationMetadata"].isNull())
lifecycleHooksObject.notificationMetadata = valueLifecycleHooksLifecycleHook["NotificationMetadata"].asString();
if(!valueLifecycleHooksLifecycleHook["NotificationArn"].isNull())
lifecycleHooksObject.notificationArn = valueLifecycleHooksLifecycleHook["NotificationArn"].asString();
lifecycleHooks_.push_back(lifecycleHooksObject);
}
if(!value["TotalCount"].isNull())

12
ess/src/model/DescribeNotificationConfigurationsResult.cc
View File

@@ -39,14 +39,14 @@ void DescribeNotificationConfigurationsResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allNotificationConfigurationModels = value["NotificationConfigurationModels"]["NotificationConfigurationModel"];
for (auto value : allNotificationConfigurationModels)
auto allNotificationConfigurationModelsNode = value["NotificationConfigurationModels"]["NotificationConfigurationModel"];
for (auto valueNotificationConfigurationModelsNotificationConfigurationModel : allNotificationConfigurationModelsNode)
{
NotificationConfigurationModel notificationConfigurationModelsObject;
if(!value["ScalingGroupId"].isNull())
notificationConfigurationModelsObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["NotificationArn"].isNull())
notificationConfigurationModelsObject.notificationArn = value["NotificationArn"].asString();
if(!valueNotificationConfigurationModelsNotificationConfigurationModel["ScalingGroupId"].isNull())
notificationConfigurationModelsObject.scalingGroupId = valueNotificationConfigurationModelsNotificationConfigurationModel["ScalingGroupId"].asString();
if(!valueNotificationConfigurationModelsNotificationConfigurationModel["NotificationArn"].isNull())
notificationConfigurationModelsObject.notificationArn = valueNotificationConfigurationModelsNotificationConfigurationModel["NotificationArn"].asString();
auto allNotificationTypes = value["NotificationTypes"]["NotificationType"];
for (auto value : allNotificationTypes)
notificationConfigurationModelsObject.notificationTypes.push_back(value.asString());

24
ess/src/model/DescribeRegionsResult.cc
View File

@@ -39,20 +39,20 @@ void DescribeRegionsResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRegions = value["Regions"]["Region"];
for (auto value : allRegions)
auto allRegionsNode = value["Regions"]["Region"];
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!value["RegionId"].isNull())
regionsObject.regionId = value["RegionId"].asString();
if(!value["ClassicUnavailable"].isNull())
regionsObject.classicUnavailable = value["ClassicUnavailable"].asString() == "true";
if(!value["VpcUnavailable"].isNull())
regionsObject.vpcUnavailable = value["VpcUnavailable"].asString() == "true";
if(!value["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = value["RegionEndpoint"].asString();
if(!value["LocalName"].isNull())
regionsObject.localName = value["LocalName"].asString();
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
if(!valueRegionsRegion["ClassicUnavailable"].isNull())
regionsObject.classicUnavailable = valueRegionsRegion["ClassicUnavailable"].asString() == "true";
if(!valueRegionsRegion["VpcUnavailable"].isNull())
regionsObject.vpcUnavailable = valueRegionsRegion["VpcUnavailable"].asString() == "true";
if(!valueRegionsRegion["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
regions_.push_back(regionsObject);
}

56
ess/src/model/DescribeScalingActivitiesResult.cc
View File

@@ -39,36 +39,36 @@ void DescribeScalingActivitiesResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allScalingActivities = value["ScalingActivities"]["ScalingActivity"];
for (auto value : allScalingActivities)
auto allScalingActivitiesNode = value["ScalingActivities"]["ScalingActivity"];
for (auto valueScalingActivitiesScalingActivity : allScalingActivitiesNode)
{
ScalingActivity scalingActivitiesObject;
if(!value["ScalingActivityId"].isNull())
scalingActivitiesObject.scalingActivityId = value["ScalingActivityId"].asString();
if(!value["ScalingGroupId"].isNull())
scalingActivitiesObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["Description"].isNull())
scalingActivitiesObject.description = value["Description"].asString();
if(!value["Cause"].isNull())
scalingActivitiesObject.cause = value["Cause"].asString();
if(!value["StartTime"].isNull())
scalingActivitiesObject.startTime = value["StartTime"].asString();
if(!value["EndTime"].isNull())
scalingActivitiesObject.endTime = value["EndTime"].asString();
if(!value["Progress"].isNull())
scalingActivitiesObject.progress = std::stoi(value["Progress"].asString());
if(!value["StatusCode"].isNull())
scalingActivitiesObject.statusCode = value["StatusCode"].asString();
if(!value["StatusMessage"].isNull())
scalingActivitiesObject.statusMessage = value["StatusMessage"].asString();
if(!value["TotalCapacity"].isNull())
scalingActivitiesObject.totalCapacity = value["TotalCapacity"].asString();
if(!value["AttachedCapacity"].isNull())
scalingActivitiesObject.attachedCapacity = value["AttachedCapacity"].asString();
if(!value["AutoCreatedCapacity"].isNull())
scalingActivitiesObject.autoCreatedCapacity = value["AutoCreatedCapacity"].asString();
if(!value["ScalingInstanceNumber"].isNull())
scalingActivitiesObject.scalingInstanceNumber = std::stoi(value["ScalingInstanceNumber"].asString());
if(!valueScalingActivitiesScalingActivity["ScalingActivityId"].isNull())
scalingActivitiesObject.scalingActivityId = valueScalingActivitiesScalingActivity["ScalingActivityId"].asString();
if(!valueScalingActivitiesScalingActivity["ScalingGroupId"].isNull())
scalingActivitiesObject.scalingGroupId = valueScalingActivitiesScalingActivity["ScalingGroupId"].asString();
if(!valueScalingActivitiesScalingActivity["Description"].isNull())
scalingActivitiesObject.description = valueScalingActivitiesScalingActivity["Description"].asString();
if(!valueScalingActivitiesScalingActivity["Cause"].isNull())
scalingActivitiesObject.cause = valueScalingActivitiesScalingActivity["Cause"].asString();
if(!valueScalingActivitiesScalingActivity["StartTime"].isNull())
scalingActivitiesObject.startTime = valueScalingActivitiesScalingActivity["StartTime"].asString();
if(!valueScalingActivitiesScalingActivity["EndTime"].isNull())
scalingActivitiesObject.endTime = valueScalingActivitiesScalingActivity["EndTime"].asString();
if(!valueScalingActivitiesScalingActivity["Progress"].isNull())
scalingActivitiesObject.progress = std::stoi(valueScalingActivitiesScalingActivity["Progress"].asString());
if(!valueScalingActivitiesScalingActivity["StatusCode"].isNull())
scalingActivitiesObject.statusCode = valueScalingActivitiesScalingActivity["StatusCode"].asString();
if(!valueScalingActivitiesScalingActivity["StatusMessage"].isNull())
scalingActivitiesObject.statusMessage = valueScalingActivitiesScalingActivity["StatusMessage"].asString();
if(!valueScalingActivitiesScalingActivity["TotalCapacity"].isNull())
scalingActivitiesObject.totalCapacity = valueScalingActivitiesScalingActivity["TotalCapacity"].asString();
if(!valueScalingActivitiesScalingActivity["AttachedCapacity"].isNull())
scalingActivitiesObject.attachedCapacity = valueScalingActivitiesScalingActivity["AttachedCapacity"].asString();
if(!valueScalingActivitiesScalingActivity["AutoCreatedCapacity"].isNull())
scalingActivitiesObject.autoCreatedCapacity = valueScalingActivitiesScalingActivity["AutoCreatedCapacity"].asString();
if(!valueScalingActivitiesScalingActivity["ScalingInstanceNumber"].isNull())
scalingActivitiesObject.scalingInstanceNumber = std::stoi(valueScalingActivitiesScalingActivity["ScalingInstanceNumber"].asString());
scalingActivities_.push_back(scalingActivitiesObject);
}
if(!value["TotalCount"].isNull())

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

@@ -39,118 +39,118 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allScalingConfigurations = value["ScalingConfigurations"]["ScalingConfiguration"];
for (auto value : allScalingConfigurations)
auto allScalingConfigurationsNode = value["ScalingConfigurations"]["ScalingConfiguration"];
for (auto valueScalingConfigurationsScalingConfiguration : allScalingConfigurationsNode)
{
ScalingConfiguration scalingConfigurationsObject;
if(!value["ScalingConfigurationId"].isNull())
scalingConfigurationsObject.scalingConfigurationId = value["ScalingConfigurationId"].asString();
if(!value["ScalingConfigurationName"].isNull())
scalingConfigurationsObject.scalingConfigurationName = value["ScalingConfigurationName"].asString();
if(!value["ScalingGroupId"].isNull())
scalingConfigurationsObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["InstanceName"].isNull())
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())
scalingConfigurationsObject.instanceType = value["InstanceType"].asString();
if(!value["Cpu"].isNull())
scalingConfigurationsObject.cpu = std::stoi(value["Cpu"].asString());
if(!value["Memory"].isNull())
scalingConfigurationsObject.memory = std::stoi(value["Memory"].asString());
if(!value["InstanceGeneration"].isNull())
scalingConfigurationsObject.instanceGeneration = value["InstanceGeneration"].asString();
if(!value["SecurityGroupId"].isNull())
scalingConfigurationsObject.securityGroupId = value["SecurityGroupId"].asString();
if(!value["IoOptimized"].isNull())
scalingConfigurationsObject.ioOptimized = value["IoOptimized"].asString();
if(!value["InternetChargeType"].isNull())
scalingConfigurationsObject.internetChargeType = value["InternetChargeType"].asString();
if(!value["InternetMaxBandwidthIn"].isNull())
scalingConfigurationsObject.internetMaxBandwidthIn = std::stoi(value["InternetMaxBandwidthIn"].asString());
if(!value["InternetMaxBandwidthOut"].isNull())
scalingConfigurationsObject.internetMaxBandwidthOut = std::stoi(value["InternetMaxBandwidthOut"].asString());
if(!value["SystemDiskCategory"].isNull())
scalingConfigurationsObject.systemDiskCategory = value["SystemDiskCategory"].asString();
if(!value["SystemDiskSize"].isNull())
scalingConfigurationsObject.systemDiskSize = std::stoi(value["SystemDiskSize"].asString());
if(!value["SystemDiskName"].isNull())
scalingConfigurationsObject.systemDiskName = value["SystemDiskName"].asString();
if(!value["SystemDiskDescription"].isNull())
scalingConfigurationsObject.systemDiskDescription = value["SystemDiskDescription"].asString();
if(!value["LifecycleState"].isNull())
scalingConfigurationsObject.lifecycleState = value["LifecycleState"].asString();
if(!value["CreationTime"].isNull())
scalingConfigurationsObject.creationTime = value["CreationTime"].asString();
if(!value["LoadBalancerWeight"].isNull())
scalingConfigurationsObject.loadBalancerWeight = std::stoi(value["LoadBalancerWeight"].asString());
if(!value["UserData"].isNull())
scalingConfigurationsObject.userData = value["UserData"].asString();
if(!value["KeyPairName"].isNull())
scalingConfigurationsObject.keyPairName = value["KeyPairName"].asString();
if(!value["RamRoleName"].isNull())
scalingConfigurationsObject.ramRoleName = value["RamRoleName"].asString();
if(!value["DeploymentSetId"].isNull())
scalingConfigurationsObject.deploymentSetId = value["DeploymentSetId"].asString();
if(!value["SecurityEnhancementStrategy"].isNull())
scalingConfigurationsObject.securityEnhancementStrategy = value["SecurityEnhancementStrategy"].asString();
if(!value["SpotStrategy"].isNull())
scalingConfigurationsObject.spotStrategy = value["SpotStrategy"].asString();
if(!value["PasswordInherit"].isNull())
scalingConfigurationsObject.passwordInherit = value["PasswordInherit"].asString() == "true";
if(!value["ResourceGroupId"].isNull())
scalingConfigurationsObject.resourceGroupId = value["ResourceGroupId"].asString();
if(!value["HpcClusterId"].isNull())
scalingConfigurationsObject.hpcClusterId = value["HpcClusterId"].asString();
if(!value["InstanceDescription"].isNull())
scalingConfigurationsObject.instanceDescription = value["InstanceDescription"].asString();
auto allDataDisks = value["DataDisks"]["DataDisk"];
for (auto value : allDataDisks)
if(!valueScalingConfigurationsScalingConfiguration["ScalingConfigurationId"].isNull())
scalingConfigurationsObject.scalingConfigurationId = valueScalingConfigurationsScalingConfiguration["ScalingConfigurationId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["ScalingConfigurationName"].isNull())
scalingConfigurationsObject.scalingConfigurationName = valueScalingConfigurationsScalingConfiguration["ScalingConfigurationName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["ScalingGroupId"].isNull())
scalingConfigurationsObject.scalingGroupId = valueScalingConfigurationsScalingConfiguration["ScalingGroupId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["InstanceName"].isNull())
scalingConfigurationsObject.instanceName = valueScalingConfigurationsScalingConfiguration["InstanceName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["ImageId"].isNull())
scalingConfigurationsObject.imageId = valueScalingConfigurationsScalingConfiguration["ImageId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["ImageName"].isNull())
scalingConfigurationsObject.imageName = valueScalingConfigurationsScalingConfiguration["ImageName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["HostName"].isNull())
scalingConfigurationsObject.hostName = valueScalingConfigurationsScalingConfiguration["HostName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["InstanceType"].isNull())
scalingConfigurationsObject.instanceType = valueScalingConfigurationsScalingConfiguration["InstanceType"].asString();
if(!valueScalingConfigurationsScalingConfiguration["Cpu"].isNull())
scalingConfigurationsObject.cpu = std::stoi(valueScalingConfigurationsScalingConfiguration["Cpu"].asString());
if(!valueScalingConfigurationsScalingConfiguration["Memory"].isNull())
scalingConfigurationsObject.memory = std::stoi(valueScalingConfigurationsScalingConfiguration["Memory"].asString());
if(!valueScalingConfigurationsScalingConfiguration["InstanceGeneration"].isNull())
scalingConfigurationsObject.instanceGeneration = valueScalingConfigurationsScalingConfiguration["InstanceGeneration"].asString();
if(!valueScalingConfigurationsScalingConfiguration["SecurityGroupId"].isNull())
scalingConfigurationsObject.securityGroupId = valueScalingConfigurationsScalingConfiguration["SecurityGroupId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["IoOptimized"].isNull())
scalingConfigurationsObject.ioOptimized = valueScalingConfigurationsScalingConfiguration["IoOptimized"].asString();
if(!valueScalingConfigurationsScalingConfiguration["InternetChargeType"].isNull())
scalingConfigurationsObject.internetChargeType = valueScalingConfigurationsScalingConfiguration["InternetChargeType"].asString();
if(!valueScalingConfigurationsScalingConfiguration["InternetMaxBandwidthIn"].isNull())
scalingConfigurationsObject.internetMaxBandwidthIn = std::stoi(valueScalingConfigurationsScalingConfiguration["InternetMaxBandwidthIn"].asString());
if(!valueScalingConfigurationsScalingConfiguration["InternetMaxBandwidthOut"].isNull())
scalingConfigurationsObject.internetMaxBandwidthOut = std::stoi(valueScalingConfigurationsScalingConfiguration["InternetMaxBandwidthOut"].asString());
if(!valueScalingConfigurationsScalingConfiguration["SystemDiskCategory"].isNull())
scalingConfigurationsObject.systemDiskCategory = valueScalingConfigurationsScalingConfiguration["SystemDiskCategory"].asString();
if(!valueScalingConfigurationsScalingConfiguration["SystemDiskSize"].isNull())
scalingConfigurationsObject.systemDiskSize = std::stoi(valueScalingConfigurationsScalingConfiguration["SystemDiskSize"].asString());
if(!valueScalingConfigurationsScalingConfiguration["SystemDiskName"].isNull())
scalingConfigurationsObject.systemDiskName = valueScalingConfigurationsScalingConfiguration["SystemDiskName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["SystemDiskDescription"].isNull())
scalingConfigurationsObject.systemDiskDescription = valueScalingConfigurationsScalingConfiguration["SystemDiskDescription"].asString();
if(!valueScalingConfigurationsScalingConfiguration["LifecycleState"].isNull())
scalingConfigurationsObject.lifecycleState = valueScalingConfigurationsScalingConfiguration["LifecycleState"].asString();
if(!valueScalingConfigurationsScalingConfiguration["CreationTime"].isNull())
scalingConfigurationsObject.creationTime = valueScalingConfigurationsScalingConfiguration["CreationTime"].asString();
if(!valueScalingConfigurationsScalingConfiguration["LoadBalancerWeight"].isNull())
scalingConfigurationsObject.loadBalancerWeight = std::stoi(valueScalingConfigurationsScalingConfiguration["LoadBalancerWeight"].asString());
if(!valueScalingConfigurationsScalingConfiguration["UserData"].isNull())
scalingConfigurationsObject.userData = valueScalingConfigurationsScalingConfiguration["UserData"].asString();
if(!valueScalingConfigurationsScalingConfiguration["KeyPairName"].isNull())
scalingConfigurationsObject.keyPairName = valueScalingConfigurationsScalingConfiguration["KeyPairName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["RamRoleName"].isNull())
scalingConfigurationsObject.ramRoleName = valueScalingConfigurationsScalingConfiguration["RamRoleName"].asString();
if(!valueScalingConfigurationsScalingConfiguration["DeploymentSetId"].isNull())
scalingConfigurationsObject.deploymentSetId = valueScalingConfigurationsScalingConfiguration["DeploymentSetId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["SecurityEnhancementStrategy"].isNull())
scalingConfigurationsObject.securityEnhancementStrategy = valueScalingConfigurationsScalingConfiguration["SecurityEnhancementStrategy"].asString();
if(!valueScalingConfigurationsScalingConfiguration["SpotStrategy"].isNull())
scalingConfigurationsObject.spotStrategy = valueScalingConfigurationsScalingConfiguration["SpotStrategy"].asString();
if(!valueScalingConfigurationsScalingConfiguration["PasswordInherit"].isNull())
scalingConfigurationsObject.passwordInherit = valueScalingConfigurationsScalingConfiguration["PasswordInherit"].asString() == "true";
if(!valueScalingConfigurationsScalingConfiguration["ResourceGroupId"].isNull())
scalingConfigurationsObject.resourceGroupId = valueScalingConfigurationsScalingConfiguration["ResourceGroupId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["HpcClusterId"].isNull())
scalingConfigurationsObject.hpcClusterId = valueScalingConfigurationsScalingConfiguration["HpcClusterId"].asString();
if(!valueScalingConfigurationsScalingConfiguration["InstanceDescription"].isNull())
scalingConfigurationsObject.instanceDescription = valueScalingConfigurationsScalingConfiguration["InstanceDescription"].asString();
auto allDataDisksNode = allScalingConfigurationsNode["DataDisks"]["DataDisk"];
for (auto allScalingConfigurationsNodeDataDisksDataDisk : allDataDisksNode)
{
ScalingConfiguration::DataDisk dataDisksObject;
if(!value["Size"].isNull())
dataDisksObject.size = std::stoi(value["Size"].asString());
if(!value["Category"].isNull())
dataDisksObject.category = value["Category"].asString();
if(!value["SnapshotId"].isNull())
dataDisksObject.snapshotId = value["SnapshotId"].asString();
if(!value["Device"].isNull())
dataDisksObject.device = value["Device"].asString();
if(!value["DeleteWithInstance"].isNull())
dataDisksObject.deleteWithInstance = value["DeleteWithInstance"].asString() == "true";
if(!value["Encrypted"].isNull())
dataDisksObject.encrypted = value["Encrypted"].asString();
if(!value["KMSKeyId"].isNull())
dataDisksObject.kMSKeyId = value["KMSKeyId"].asString();
if(!value["DiskName"].isNull())
dataDisksObject.diskName = value["DiskName"].asString();
if(!value["Description"].isNull())
dataDisksObject.description = value["Description"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["Size"].isNull())
dataDisksObject.size = std::stoi(allScalingConfigurationsNodeDataDisksDataDisk["Size"].asString());
if(!allScalingConfigurationsNodeDataDisksDataDisk["Category"].isNull())
dataDisksObject.category = allScalingConfigurationsNodeDataDisksDataDisk["Category"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["SnapshotId"].isNull())
dataDisksObject.snapshotId = allScalingConfigurationsNodeDataDisksDataDisk["SnapshotId"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["Device"].isNull())
dataDisksObject.device = allScalingConfigurationsNodeDataDisksDataDisk["Device"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["DeleteWithInstance"].isNull())
dataDisksObject.deleteWithInstance = allScalingConfigurationsNodeDataDisksDataDisk["DeleteWithInstance"].asString() == "true";
if(!allScalingConfigurationsNodeDataDisksDataDisk["Encrypted"].isNull())
dataDisksObject.encrypted = allScalingConfigurationsNodeDataDisksDataDisk["Encrypted"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["KMSKeyId"].isNull())
dataDisksObject.kMSKeyId = allScalingConfigurationsNodeDataDisksDataDisk["KMSKeyId"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["DiskName"].isNull())
dataDisksObject.diskName = allScalingConfigurationsNodeDataDisksDataDisk["DiskName"].asString();
if(!allScalingConfigurationsNodeDataDisksDataDisk["Description"].isNull())
dataDisksObject.description = allScalingConfigurationsNodeDataDisksDataDisk["Description"].asString();
scalingConfigurationsObject.dataDisks.push_back(dataDisksObject);
}
auto allTags = value["Tags"]["Tag"];
for (auto value : allTags)
auto allTagsNode = allScalingConfigurationsNode["Tags"]["Tag"];
for (auto allScalingConfigurationsNodeTagsTag : allTagsNode)
{
ScalingConfiguration::Tag tagsObject;
if(!value["Key"].isNull())
tagsObject.key = value["Key"].asString();
if(!value["Value"].isNull())
tagsObject.value = value["Value"].asString();
if(!allScalingConfigurationsNodeTagsTag["Key"].isNull())
tagsObject.key = allScalingConfigurationsNodeTagsTag["Key"].asString();
if(!allScalingConfigurationsNodeTagsTag["Value"].isNull())
tagsObject.value = allScalingConfigurationsNodeTagsTag["Value"].asString();
scalingConfigurationsObject.tags.push_back(tagsObject);
}
auto allSpotPriceLimit = value["SpotPriceLimit"]["SpotPriceModel"];
for (auto value : allSpotPriceLimit)
auto allSpotPriceLimitNode = allScalingConfigurationsNode["SpotPriceLimit"]["SpotPriceModel"];
for (auto allScalingConfigurationsNodeSpotPriceLimitSpotPriceModel : allSpotPriceLimitNode)
{
ScalingConfiguration::SpotPriceModel spotPriceLimitObject;
if(!value["InstanceType"].isNull())
spotPriceLimitObject.instanceType = value["InstanceType"].asString();
if(!value["PriceLimit"].isNull())
spotPriceLimitObject.priceLimit = std::stof(value["PriceLimit"].asString());
if(!allScalingConfigurationsNodeSpotPriceLimitSpotPriceModel["InstanceType"].isNull())
spotPriceLimitObject.instanceType = allScalingConfigurationsNodeSpotPriceLimitSpotPriceModel["InstanceType"].asString();
if(!allScalingConfigurationsNodeSpotPriceLimitSpotPriceModel["PriceLimit"].isNull())
spotPriceLimitObject.priceLimit = std::stof(allScalingConfigurationsNodeSpotPriceLimitSpotPriceModel["PriceLimit"].asString());
scalingConfigurationsObject.spotPriceLimit.push_back(spotPriceLimitObject);
}
auto allInstanceTypes = value["InstanceTypes"]["InstanceType"];

148
ess/src/model/DescribeScalingGroupsResult.cc
View File

@@ -39,86 +39,86 @@ void DescribeScalingGroupsResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allScalingGroups = value["ScalingGroups"]["ScalingGroup"];
for (auto value : allScalingGroups)
auto allScalingGroupsNode = value["ScalingGroups"]["ScalingGroup"];
for (auto valueScalingGroupsScalingGroup : allScalingGroupsNode)
{
ScalingGroup scalingGroupsObject;
if(!value["DefaultCooldown"].isNull())
scalingGroupsObject.defaultCooldown = std::stoi(value["DefaultCooldown"].asString());
if(!value["MaxSize"].isNull())
scalingGroupsObject.maxSize = std::stoi(value["MaxSize"].asString());
if(!value["PendingWaitCapacity"].isNull())
scalingGroupsObject.pendingWaitCapacity = std::stoi(value["PendingWaitCapacity"].asString());
if(!value["RemovingWaitCapacity"].isNull())
scalingGroupsObject.removingWaitCapacity = std::stoi(value["RemovingWaitCapacity"].asString());
if(!value["PendingCapacity"].isNull())
scalingGroupsObject.pendingCapacity = std::stoi(value["PendingCapacity"].asString());
if(!value["RemovingCapacity"].isNull())
scalingGroupsObject.removingCapacity = std::stoi(value["RemovingCapacity"].asString());
if(!value["ScalingGroupName"].isNull())
scalingGroupsObject.scalingGroupName = value["ScalingGroupName"].asString();
if(!value["ActiveCapacity"].isNull())
scalingGroupsObject.activeCapacity = std::stoi(value["ActiveCapacity"].asString());
if(!value["StandbyCapacity"].isNull())
scalingGroupsObject.standbyCapacity = std::stoi(value["StandbyCapacity"].asString());
if(!value["ProtectedCapacity"].isNull())
scalingGroupsObject.protectedCapacity = std::stoi(value["ProtectedCapacity"].asString());
if(!value["ActiveScalingConfigurationId"].isNull())
scalingGroupsObject.activeScalingConfigurationId = value["ActiveScalingConfigurationId"].asString();
if(!value["LaunchTemplateId"].isNull())
scalingGroupsObject.launchTemplateId = value["LaunchTemplateId"].asString();
if(!value["LaunchTemplateVersion"].isNull())
scalingGroupsObject.launchTemplateVersion = value["LaunchTemplateVersion"].asString();
if(!value["ScalingGroupId"].isNull())
scalingGroupsObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["RegionId"].isNull())
scalingGroupsObject.regionId = value["RegionId"].asString();
if(!value["TotalCapacity"].isNull())
scalingGroupsObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
if(!value["MinSize"].isNull())
scalingGroupsObject.minSize = std::stoi(value["MinSize"].asString());
if(!value["LifecycleState"].isNull())
scalingGroupsObject.lifecycleState = value["LifecycleState"].asString();
if(!value["CreationTime"].isNull())
scalingGroupsObject.creationTime = value["CreationTime"].asString();
if(!value["ModificationTime"].isNull())
scalingGroupsObject.modificationTime = value["ModificationTime"].asString();
if(!value["VpcId"].isNull())
scalingGroupsObject.vpcId = value["VpcId"].asString();
if(!value["VSwitchId"].isNull())
scalingGroupsObject.vSwitchId = value["VSwitchId"].asString();
if(!value["MultiAZPolicy"].isNull())
scalingGroupsObject.multiAZPolicy = value["MultiAZPolicy"].asString();
if(!value["HealthCheckType"].isNull())
scalingGroupsObject.healthCheckType = value["HealthCheckType"].asString();
if(!value["ScalingPolicy"].isNull())
scalingGroupsObject.scalingPolicy = value["ScalingPolicy"].asString();
if(!value["StoppedCapacity"].isNull())
scalingGroupsObject.stoppedCapacity = std::stoi(value["StoppedCapacity"].asString());
if(!value["OnDemandBaseCapacity"].isNull())
scalingGroupsObject.onDemandBaseCapacity = std::stoi(value["OnDemandBaseCapacity"].asString());
if(!value["OnDemandPercentageAboveBaseCapacity"].isNull())
scalingGroupsObject.onDemandPercentageAboveBaseCapacity = std::stoi(value["OnDemandPercentageAboveBaseCapacity"].asString());
if(!value["SpotInstanceRemedy"].isNull())
scalingGroupsObject.spotInstanceRemedy = value["SpotInstanceRemedy"].asString() == "true";
if(!value["SpotInstancePools"].isNull())
scalingGroupsObject.spotInstancePools = std::stoi(value["SpotInstancePools"].asString());
auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
for (auto value : allVServerGroups)
if(!valueScalingGroupsScalingGroup["DefaultCooldown"].isNull())
scalingGroupsObject.defaultCooldown = std::stoi(valueScalingGroupsScalingGroup["DefaultCooldown"].asString());
if(!valueScalingGroupsScalingGroup["MaxSize"].isNull())
scalingGroupsObject.maxSize = std::stoi(valueScalingGroupsScalingGroup["MaxSize"].asString());
if(!valueScalingGroupsScalingGroup["PendingWaitCapacity"].isNull())
scalingGroupsObject.pendingWaitCapacity = std::stoi(valueScalingGroupsScalingGroup["PendingWaitCapacity"].asString());
if(!valueScalingGroupsScalingGroup["RemovingWaitCapacity"].isNull())
scalingGroupsObject.removingWaitCapacity = std::stoi(valueScalingGroupsScalingGroup["RemovingWaitCapacity"].asString());
if(!valueScalingGroupsScalingGroup["PendingCapacity"].isNull())
scalingGroupsObject.pendingCapacity = std::stoi(valueScalingGroupsScalingGroup["PendingCapacity"].asString());
if(!valueScalingGroupsScalingGroup["RemovingCapacity"].isNull())
scalingGroupsObject.removingCapacity = std::stoi(valueScalingGroupsScalingGroup["RemovingCapacity"].asString());
if(!valueScalingGroupsScalingGroup["ScalingGroupName"].isNull())
scalingGroupsObject.scalingGroupName = valueScalingGroupsScalingGroup["ScalingGroupName"].asString();
if(!valueScalingGroupsScalingGroup["ActiveCapacity"].isNull())
scalingGroupsObject.activeCapacity = std::stoi(valueScalingGroupsScalingGroup["ActiveCapacity"].asString());
if(!valueScalingGroupsScalingGroup["StandbyCapacity"].isNull())
scalingGroupsObject.standbyCapacity = std::stoi(valueScalingGroupsScalingGroup["StandbyCapacity"].asString());
if(!valueScalingGroupsScalingGroup["ProtectedCapacity"].isNull())
scalingGroupsObject.protectedCapacity = std::stoi(valueScalingGroupsScalingGroup["ProtectedCapacity"].asString());
if(!valueScalingGroupsScalingGroup["ActiveScalingConfigurationId"].isNull())
scalingGroupsObject.activeScalingConfigurationId = valueScalingGroupsScalingGroup["ActiveScalingConfigurationId"].asString();
if(!valueScalingGroupsScalingGroup["LaunchTemplateId"].isNull())
scalingGroupsObject.launchTemplateId = valueScalingGroupsScalingGroup["LaunchTemplateId"].asString();
if(!valueScalingGroupsScalingGroup["LaunchTemplateVersion"].isNull())
scalingGroupsObject.launchTemplateVersion = valueScalingGroupsScalingGroup["LaunchTemplateVersion"].asString();
if(!valueScalingGroupsScalingGroup["ScalingGroupId"].isNull())
scalingGroupsObject.scalingGroupId = valueScalingGroupsScalingGroup["ScalingGroupId"].asString();
if(!valueScalingGroupsScalingGroup["RegionId"].isNull())
scalingGroupsObject.regionId = valueScalingGroupsScalingGroup["RegionId"].asString();
if(!valueScalingGroupsScalingGroup["TotalCapacity"].isNull())
scalingGroupsObject.totalCapacity = std::stoi(valueScalingGroupsScalingGroup["TotalCapacity"].asString());
if(!valueScalingGroupsScalingGroup["MinSize"].isNull())
scalingGroupsObject.minSize = std::stoi(valueScalingGroupsScalingGroup["MinSize"].asString());
if(!valueScalingGroupsScalingGroup["LifecycleState"].isNull())
scalingGroupsObject.lifecycleState = valueScalingGroupsScalingGroup["LifecycleState"].asString();
if(!valueScalingGroupsScalingGroup["CreationTime"].isNull())
scalingGroupsObject.creationTime = valueScalingGroupsScalingGroup["CreationTime"].asString();
if(!valueScalingGroupsScalingGroup["ModificationTime"].isNull())
scalingGroupsObject.modificationTime = valueScalingGroupsScalingGroup["ModificationTime"].asString();
if(!valueScalingGroupsScalingGroup["VpcId"].isNull())
scalingGroupsObject.vpcId = valueScalingGroupsScalingGroup["VpcId"].asString();
if(!valueScalingGroupsScalingGroup["VSwitchId"].isNull())
scalingGroupsObject.vSwitchId = valueScalingGroupsScalingGroup["VSwitchId"].asString();
if(!valueScalingGroupsScalingGroup["MultiAZPolicy"].isNull())
scalingGroupsObject.multiAZPolicy = valueScalingGroupsScalingGroup["MultiAZPolicy"].asString();
if(!valueScalingGroupsScalingGroup["HealthCheckType"].isNull())
scalingGroupsObject.healthCheckType = valueScalingGroupsScalingGroup["HealthCheckType"].asString();
if(!valueScalingGroupsScalingGroup["ScalingPolicy"].isNull())
scalingGroupsObject.scalingPolicy = valueScalingGroupsScalingGroup["ScalingPolicy"].asString();
if(!valueScalingGroupsScalingGroup["StoppedCapacity"].isNull())
scalingGroupsObject.stoppedCapacity = std::stoi(valueScalingGroupsScalingGroup["StoppedCapacity"].asString());
if(!valueScalingGroupsScalingGroup["OnDemandBaseCapacity"].isNull())
scalingGroupsObject.onDemandBaseCapacity = std::stoi(valueScalingGroupsScalingGroup["OnDemandBaseCapacity"].asString());
if(!valueScalingGroupsScalingGroup["OnDemandPercentageAboveBaseCapacity"].isNull())
scalingGroupsObject.onDemandPercentageAboveBaseCapacity = std::stoi(valueScalingGroupsScalingGroup["OnDemandPercentageAboveBaseCapacity"].asString());
if(!valueScalingGroupsScalingGroup["SpotInstanceRemedy"].isNull())
scalingGroupsObject.spotInstanceRemedy = valueScalingGroupsScalingGroup["SpotInstanceRemedy"].asString() == "true";
if(!valueScalingGroupsScalingGroup["SpotInstancePools"].isNull())
scalingGroupsObject.spotInstancePools = std::stoi(valueScalingGroupsScalingGroup["SpotInstancePools"].asString());
auto allVServerGroupsNode = allScalingGroupsNode["VServerGroups"]["VServerGroup"];
for (auto allScalingGroupsNodeVServerGroupsVServerGroup : allVServerGroupsNode)
{
ScalingGroup::VServerGroup vServerGroupsObject;
if(!value["LoadBalancerId"].isNull())
vServerGroupsObject.loadBalancerId = value["LoadBalancerId"].asString();
auto allVServerGroupAttributes = value["VServerGroupAttributes"]["VServerGroupAttribute"];
for (auto value : allVServerGroupAttributes)
if(!allScalingGroupsNodeVServerGroupsVServerGroup["LoadBalancerId"].isNull())
vServerGroupsObject.loadBalancerId = allScalingGroupsNodeVServerGroupsVServerGroup["LoadBalancerId"].asString();
auto allVServerGroupAttributesNode = allVServerGroupsNode["VServerGroupAttributes"]["VServerGroupAttribute"];
for (auto allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute : allVServerGroupAttributesNode)
{
ScalingGroup::VServerGroup::VServerGroupAttribute vServerGroupAttributesObject;
if(!value["VServerGroupId"].isNull())
vServerGroupAttributesObject.vServerGroupId = value["VServerGroupId"].asString();
if(!value["Port"].isNull())
vServerGroupAttributesObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
vServerGroupAttributesObject.weight = std::stoi(value["Weight"].asString());
if(!allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute["VServerGroupId"].isNull())
vServerGroupAttributesObject.vServerGroupId = allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute["VServerGroupId"].asString();
if(!allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute["Port"].isNull())
vServerGroupAttributesObject.port = std::stoi(allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute["Port"].asString());
if(!allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute["Weight"].isNull())
vServerGroupAttributesObject.weight = std::stoi(allVServerGroupsNodeVServerGroupAttributesVServerGroupAttribute["Weight"].asString());
vServerGroupsObject.vServerGroupAttributes.push_back(vServerGroupAttributesObject);
}
scalingGroupsObject.vServerGroups.push_back(vServerGroupsObject);

48
ess/src/model/DescribeScalingInstancesResult.cc
View File

@@ -39,32 +39,32 @@ void DescribeScalingInstancesResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allScalingInstances = value["ScalingInstances"]["ScalingInstance"];
for (auto value : allScalingInstances)
auto allScalingInstancesNode = value["ScalingInstances"]["ScalingInstance"];
for (auto valueScalingInstancesScalingInstance : allScalingInstancesNode)
{
ScalingInstance scalingInstancesObject;
if(!value["InstanceId"].isNull())
scalingInstancesObject.instanceId = value["InstanceId"].asString();
if(!value["ScalingConfigurationId"].isNull())
scalingInstancesObject.scalingConfigurationId = value["ScalingConfigurationId"].asString();
if(!value["ScalingGroupId"].isNull())
scalingInstancesObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["HealthStatus"].isNull())
scalingInstancesObject.healthStatus = value["HealthStatus"].asString();
if(!value["LoadBalancerWeight"].isNull())
scalingInstancesObject.loadBalancerWeight = std::stoi(value["LoadBalancerWeight"].asString());
if(!value["LifecycleState"].isNull())
scalingInstancesObject.lifecycleState = value["LifecycleState"].asString();
if(!value["CreationTime"].isNull())
scalingInstancesObject.creationTime = value["CreationTime"].asString();
if(!value["CreationType"].isNull())
scalingInstancesObject.creationType = value["CreationType"].asString();
if(!value["LaunchTemplateId"].isNull())
scalingInstancesObject.launchTemplateId = value["LaunchTemplateId"].asString();
if(!value["LaunchTemplateVersion"].isNull())
scalingInstancesObject.launchTemplateVersion = value["LaunchTemplateVersion"].asString();
if(!value["WarmupState"].isNull())
scalingInstancesObject.warmupState = value["WarmupState"].asString();
if(!valueScalingInstancesScalingInstance["InstanceId"].isNull())
scalingInstancesObject.instanceId = valueScalingInstancesScalingInstance["InstanceId"].asString();
if(!valueScalingInstancesScalingInstance["ScalingConfigurationId"].isNull())
scalingInstancesObject.scalingConfigurationId = valueScalingInstancesScalingInstance["ScalingConfigurationId"].asString();
if(!valueScalingInstancesScalingInstance["ScalingGroupId"].isNull())
scalingInstancesObject.scalingGroupId = valueScalingInstancesScalingInstance["ScalingGroupId"].asString();
if(!valueScalingInstancesScalingInstance["HealthStatus"].isNull())
scalingInstancesObject.healthStatus = valueScalingInstancesScalingInstance["HealthStatus"].asString();
if(!valueScalingInstancesScalingInstance["LoadBalancerWeight"].isNull())
scalingInstancesObject.loadBalancerWeight = std::stoi(valueScalingInstancesScalingInstance["LoadBalancerWeight"].asString());
if(!valueScalingInstancesScalingInstance["LifecycleState"].isNull())
scalingInstancesObject.lifecycleState = valueScalingInstancesScalingInstance["LifecycleState"].asString();
if(!valueScalingInstancesScalingInstance["CreationTime"].isNull())
scalingInstancesObject.creationTime = valueScalingInstancesScalingInstance["CreationTime"].asString();
if(!valueScalingInstancesScalingInstance["CreationType"].isNull())
scalingInstancesObject.creationType = valueScalingInstancesScalingInstance["CreationType"].asString();
if(!valueScalingInstancesScalingInstance["LaunchTemplateId"].isNull())
scalingInstancesObject.launchTemplateId = valueScalingInstancesScalingInstance["LaunchTemplateId"].asString();
if(!valueScalingInstancesScalingInstance["LaunchTemplateVersion"].isNull())
scalingInstancesObject.launchTemplateVersion = valueScalingInstancesScalingInstance["LaunchTemplateVersion"].asString();
if(!valueScalingInstancesScalingInstance["WarmupState"].isNull())
scalingInstancesObject.warmupState = valueScalingInstancesScalingInstance["WarmupState"].asString();
scalingInstances_.push_back(scalingInstancesObject);
}
if(!value["TotalCount"].isNull())

144
ess/src/model/DescribeScalingRulesResult.cc
View File

@@ -39,90 +39,90 @@ void DescribeScalingRulesResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allScalingRules = value["ScalingRules"]["ScalingRule"];
for (auto value : allScalingRules)
auto allScalingRulesNode = value["ScalingRules"]["ScalingRule"];
for (auto valueScalingRulesScalingRule : allScalingRulesNode)
{
ScalingRule scalingRulesObject;
if(!value["ScalingRuleId"].isNull())
scalingRulesObject.scalingRuleId = value["ScalingRuleId"].asString();
if(!value["ScalingGroupId"].isNull())
scalingRulesObject.scalingGroupId = value["ScalingGroupId"].asString();
if(!value["ScalingRuleName"].isNull())
scalingRulesObject.scalingRuleName = value["ScalingRuleName"].asString();
if(!value["Cooldown"].isNull())
scalingRulesObject.cooldown = std::stoi(value["Cooldown"].asString());
if(!value["MinAdjustmentMagnitude"].isNull())
scalingRulesObject.minAdjustmentMagnitude = std::stoi(value["MinAdjustmentMagnitude"].asString());
if(!value["AdjustmentType"].isNull())
scalingRulesObject.adjustmentType = value["AdjustmentType"].asString();
if(!value["AdjustmentValue"].isNull())
scalingRulesObject.adjustmentValue = std::stoi(value["AdjustmentValue"].asString());
if(!value["MinSize"].isNull())
scalingRulesObject.minSize = std::stoi(value["MinSize"].asString());
if(!value["MaxSize"].isNull())
scalingRulesObject.maxSize = std::stoi(value["MaxSize"].asString());
if(!value["ScalingRuleAri"].isNull())
scalingRulesObject.scalingRuleAri = value["ScalingRuleAri"].asString();
if(!value["ScalingRuleType"].isNull())
scalingRulesObject.scalingRuleType = value["ScalingRuleType"].asString();
if(!value["EstimatedInstanceWarmup"].isNull())
scalingRulesObject.estimatedInstanceWarmup = std::stoi(value["EstimatedInstanceWarmup"].asString());
if(!value["MetricName"].isNull())
scalingRulesObject.metricName = value["MetricName"].asString();
if(!value["TargetValue"].isNull())
scalingRulesObject.targetValue = std::stof(value["TargetValue"].asString());
if(!value["DisableScaleIn"].isNull())
scalingRulesObject.disableScaleIn = value["DisableScaleIn"].asString() == "true";
if(!value["PredictiveScalingMode"].isNull())
scalingRulesObject.predictiveScalingMode = value["PredictiveScalingMode"].asString();
if(!value["PredictiveValueBehavior"].isNull())
scalingRulesObject.predictiveValueBehavior = value["PredictiveValueBehavior"].asString();
if(!value["PredictiveValueBuffer"].isNull())
scalingRulesObject.predictiveValueBuffer = std::stoi(value["PredictiveValueBuffer"].asString());
if(!value["PredictiveTaskBufferTime"].isNull())
scalingRulesObject.predictiveTaskBufferTime = std::stoi(value["PredictiveTaskBufferTime"].asString());
if(!value["InitialMaxSize"].isNull())
scalingRulesObject.initialMaxSize = std::stoi(value["InitialMaxSize"].asString());
auto allAlarms = value["Alarms"]["Alarm"];
for (auto value : allAlarms)
if(!valueScalingRulesScalingRule["ScalingRuleId"].isNull())
scalingRulesObject.scalingRuleId = valueScalingRulesScalingRule["ScalingRuleId"].asString();
if(!valueScalingRulesScalingRule["ScalingGroupId"].isNull())
scalingRulesObject.scalingGroupId = valueScalingRulesScalingRule["ScalingGroupId"].asString();
if(!valueScalingRulesScalingRule["ScalingRuleName"].isNull())
scalingRulesObject.scalingRuleName = valueScalingRulesScalingRule["ScalingRuleName"].asString();
if(!valueScalingRulesScalingRule["Cooldown"].isNull())
scalingRulesObject.cooldown = std::stoi(valueScalingRulesScalingRule["Cooldown"].asString());
if(!valueScalingRulesScalingRule["MinAdjustmentMagnitude"].isNull())
scalingRulesObject.minAdjustmentMagnitude = std::stoi(valueScalingRulesScalingRule["MinAdjustmentMagnitude"].asString());
if(!valueScalingRulesScalingRule["AdjustmentType"].isNull())
scalingRulesObject.adjustmentType = valueScalingRulesScalingRule["AdjustmentType"].asString();
if(!valueScalingRulesScalingRule["AdjustmentValue"].isNull())
scalingRulesObject.adjustmentValue = std::stoi(valueScalingRulesScalingRule["AdjustmentValue"].asString());
if(!valueScalingRulesScalingRule["MinSize"].isNull())
scalingRulesObject.minSize = std::stoi(valueScalingRulesScalingRule["MinSize"].asString());
if(!valueScalingRulesScalingRule["MaxSize"].isNull())
scalingRulesObject.maxSize = std::stoi(valueScalingRulesScalingRule["MaxSize"].asString());
if(!valueScalingRulesScalingRule["ScalingRuleAri"].isNull())
scalingRulesObject.scalingRuleAri = valueScalingRulesScalingRule["ScalingRuleAri"].asString();
if(!valueScalingRulesScalingRule["ScalingRuleType"].isNull())
scalingRulesObject.scalingRuleType = valueScalingRulesScalingRule["ScalingRuleType"].asString();
if(!valueScalingRulesScalingRule["EstimatedInstanceWarmup"].isNull())
scalingRulesObject.estimatedInstanceWarmup = std::stoi(valueScalingRulesScalingRule["EstimatedInstanceWarmup"].asString());
if(!valueScalingRulesScalingRule["MetricName"].isNull())
scalingRulesObject.metricName = valueScalingRulesScalingRule["MetricName"].asString();
if(!valueScalingRulesScalingRule["TargetValue"].isNull())
scalingRulesObject.targetValue = std::stof(valueScalingRulesScalingRule["TargetValue"].asString());
if(!valueScalingRulesScalingRule["DisableScaleIn"].isNull())
scalingRulesObject.disableScaleIn = valueScalingRulesScalingRule["DisableScaleIn"].asString() == "true";
if(!valueScalingRulesScalingRule["PredictiveScalingMode"].isNull())
scalingRulesObject.predictiveScalingMode = valueScalingRulesScalingRule["PredictiveScalingMode"].asString();
if(!valueScalingRulesScalingRule["PredictiveValueBehavior"].isNull())
scalingRulesObject.predictiveValueBehavior = valueScalingRulesScalingRule["PredictiveValueBehavior"].asString();
if(!valueScalingRulesScalingRule["PredictiveValueBuffer"].isNull())
scalingRulesObject.predictiveValueBuffer = std::stoi(valueScalingRulesScalingRule["PredictiveValueBuffer"].asString());
if(!valueScalingRulesScalingRule["PredictiveTaskBufferTime"].isNull())
scalingRulesObject.predictiveTaskBufferTime = std::stoi(valueScalingRulesScalingRule["PredictiveTaskBufferTime"].asString());
if(!valueScalingRulesScalingRule["InitialMaxSize"].isNull())
scalingRulesObject.initialMaxSize = std::stoi(valueScalingRulesScalingRule["InitialMaxSize"].asString());
auto allAlarmsNode = allScalingRulesNode["Alarms"]["Alarm"];
for (auto allScalingRulesNodeAlarmsAlarm : allAlarmsNode)
{
ScalingRule::Alarm alarmsObject;
if(!value["AlarmTaskName"].isNull())
alarmsObject.alarmTaskName = value["AlarmTaskName"].asString();
if(!value["AlarmTaskId"].isNull())
alarmsObject.alarmTaskId = value["AlarmTaskId"].asString();
if(!value["ComparisonOperator"].isNull())
alarmsObject.comparisonOperator = value["ComparisonOperator"].asString();
if(!value["Statistics"].isNull())
alarmsObject.statistics = value["Statistics"].asString();
if(!value["MetricName"].isNull())
alarmsObject.metricName = value["MetricName"].asString();
if(!value["Threshold"].isNull())
alarmsObject.threshold = std::stof(value["Threshold"].asString());
if(!value["EvaluationCount"].isNull())
alarmsObject.evaluationCount = std::stoi(value["EvaluationCount"].asString());
auto allDimensions = value["Dimensions"]["Dimension"];
for (auto value : allDimensions)
if(!allScalingRulesNodeAlarmsAlarm["AlarmTaskName"].isNull())
alarmsObject.alarmTaskName = allScalingRulesNodeAlarmsAlarm["AlarmTaskName"].asString();
if(!allScalingRulesNodeAlarmsAlarm["AlarmTaskId"].isNull())
alarmsObject.alarmTaskId = allScalingRulesNodeAlarmsAlarm["AlarmTaskId"].asString();
if(!allScalingRulesNodeAlarmsAlarm["ComparisonOperator"].isNull())
alarmsObject.comparisonOperator = allScalingRulesNodeAlarmsAlarm["ComparisonOperator"].asString();
if(!allScalingRulesNodeAlarmsAlarm["Statistics"].isNull())
alarmsObject.statistics = allScalingRulesNodeAlarmsAlarm["Statistics"].asString();
if(!allScalingRulesNodeAlarmsAlarm["MetricName"].isNull())
alarmsObject.metricName = allScalingRulesNodeAlarmsAlarm["MetricName"].asString();
if(!allScalingRulesNodeAlarmsAlarm["Threshold"].isNull())
alarmsObject.threshold = std::stof(allScalingRulesNodeAlarmsAlarm["Threshold"].asString());
if(!allScalingRulesNodeAlarmsAlarm["EvaluationCount"].isNull())
alarmsObject.evaluationCount = std::stoi(allScalingRulesNodeAlarmsAlarm["EvaluationCount"].asString());
auto allDimensionsNode = allAlarmsNode["Dimensions"]["Dimension"];
for (auto allAlarmsNodeDimensionsDimension : allDimensionsNode)
{
ScalingRule::Alarm::Dimension dimensionsObject;
if(!value["DimensionKey"].isNull())
dimensionsObject.dimensionKey = value["DimensionKey"].asString();
if(!value["DimensionValue"].isNull())
dimensionsObject.dimensionValue = value["DimensionValue"].asString();
if(!allAlarmsNodeDimensionsDimension["DimensionKey"].isNull())
dimensionsObject.dimensionKey = allAlarmsNodeDimensionsDimension["DimensionKey"].asString();
if(!allAlarmsNodeDimensionsDimension["DimensionValue"].isNull())
dimensionsObject.dimensionValue = allAlarmsNodeDimensionsDimension["DimensionValue"].asString();
alarmsObject.dimensions.push_back(dimensionsObject);
}
scalingRulesObject.alarms.push_back(alarmsObject);
}
auto allStepAdjustments = value["StepAdjustments"]["StepAdjustment"];
for (auto value : allStepAdjustments)
auto allStepAdjustmentsNode = allScalingRulesNode["StepAdjustments"]["StepAdjustment"];
for (auto allScalingRulesNodeStepAdjustmentsStepAdjustment : allStepAdjustmentsNode)
{
ScalingRule::StepAdjustment stepAdjustmentsObject;
if(!value["MetricIntervalLowerBound"].isNull())
stepAdjustmentsObject.metricIntervalLowerBound = std::stof(value["MetricIntervalLowerBound"].asString());
if(!value["MetricIntervalUpperBound"].isNull())
stepAdjustmentsObject.metricIntervalUpperBound = std::stof(value["MetricIntervalUpperBound"].asString());
if(!value["ScalingAdjustment"].isNull())
stepAdjustmentsObject.scalingAdjustment = std::stoi(value["ScalingAdjustment"].asString());
if(!allScalingRulesNodeStepAdjustmentsStepAdjustment["MetricIntervalLowerBound"].isNull())
stepAdjustmentsObject.metricIntervalLowerBound = std::stof(allScalingRulesNodeStepAdjustmentsStepAdjustment["MetricIntervalLowerBound"].asString());
if(!allScalingRulesNodeStepAdjustmentsStepAdjustment["MetricIntervalUpperBound"].isNull())
stepAdjustmentsObject.metricIntervalUpperBound = std::stof(allScalingRulesNodeStepAdjustmentsStepAdjustment["MetricIntervalUpperBound"].asString());
if(!allScalingRulesNodeStepAdjustmentsStepAdjustment["ScalingAdjustment"].isNull())
stepAdjustmentsObject.scalingAdjustment = std::stoi(allScalingRulesNodeStepAdjustmentsStepAdjustment["ScalingAdjustment"].asString());
scalingRulesObject.stepAdjustments.push_back(stepAdjustmentsObject);
}
scalingRules_.push_back(scalingRulesObject);

52
ess/src/model/DescribeScheduledTasksResult.cc
View File

@@ -39,34 +39,34 @@ void DescribeScheduledTasksResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allScheduledTasks = value["ScheduledTasks"]["ScheduledTask"];
for (auto value : allScheduledTasks)
auto allScheduledTasksNode = value["ScheduledTasks"]["ScheduledTask"];
for (auto valueScheduledTasksScheduledTask : allScheduledTasksNode)
{
ScheduledTask scheduledTasksObject;
if(!value["ScheduledTaskId"].isNull())
scheduledTasksObject.scheduledTaskId = value["ScheduledTaskId"].asString();
if(!value["ScheduledTaskName"].isNull())
scheduledTasksObject.scheduledTaskName = value["ScheduledTaskName"].asString();
if(!value["Description"].isNull())
scheduledTasksObject.description = value["Description"].asString();
if(!value["ScheduledAction"].isNull())
scheduledTasksObject.scheduledAction = value["ScheduledAction"].asString();
if(!value["RecurrenceEndTime"].isNull())
scheduledTasksObject.recurrenceEndTime = value["RecurrenceEndTime"].asString();
if(!value["LaunchTime"].isNull())
scheduledTasksObject.launchTime = value["LaunchTime"].asString();
if(!value["RecurrenceType"].isNull())
scheduledTasksObject.recurrenceType = value["RecurrenceType"].asString();
if(!value["RecurrenceValue"].isNull())
scheduledTasksObject.recurrenceValue = value["RecurrenceValue"].asString();
if(!value["LaunchExpirationTime"].isNull())
scheduledTasksObject.launchExpirationTime = std::stoi(value["LaunchExpirationTime"].asString());
if(!value["TaskEnabled"].isNull())
scheduledTasksObject.taskEnabled = value["TaskEnabled"].asString() == "true";
if(!value["MaxValue"].isNull())
scheduledTasksObject.maxValue = std::stoi(value["MaxValue"].asString());
if(!value["MinValue"].isNull())
scheduledTasksObject.minValue = std::stoi(value["MinValue"].asString());
if(!valueScheduledTasksScheduledTask["ScheduledTaskId"].isNull())
scheduledTasksObject.scheduledTaskId = valueScheduledTasksScheduledTask["ScheduledTaskId"].asString();
if(!valueScheduledTasksScheduledTask["ScheduledTaskName"].isNull())
scheduledTasksObject.scheduledTaskName = valueScheduledTasksScheduledTask["ScheduledTaskName"].asString();
if(!valueScheduledTasksScheduledTask["Description"].isNull())
scheduledTasksObject.description = valueScheduledTasksScheduledTask["Description"].asString();
if(!valueScheduledTasksScheduledTask["ScheduledAction"].isNull())
scheduledTasksObject.scheduledAction = valueScheduledTasksScheduledTask["ScheduledAction"].asString();
if(!valueScheduledTasksScheduledTask["RecurrenceEndTime"].isNull())
scheduledTasksObject.recurrenceEndTime = valueScheduledTasksScheduledTask["RecurrenceEndTime"].asString();
if(!valueScheduledTasksScheduledTask["LaunchTime"].isNull())
scheduledTasksObject.launchTime = valueScheduledTasksScheduledTask["LaunchTime"].asString();
if(!valueScheduledTasksScheduledTask["RecurrenceType"].isNull())
scheduledTasksObject.recurrenceType = valueScheduledTasksScheduledTask["RecurrenceType"].asString();
if(!valueScheduledTasksScheduledTask["RecurrenceValue"].isNull())
scheduledTasksObject.recurrenceValue = valueScheduledTasksScheduledTask["RecurrenceValue"].asString();
if(!valueScheduledTasksScheduledTask["LaunchExpirationTime"].isNull())
scheduledTasksObject.launchExpirationTime = std::stoi(valueScheduledTasksScheduledTask["LaunchExpirationTime"].asString());
if(!valueScheduledTasksScheduledTask["TaskEnabled"].isNull())
scheduledTasksObject.taskEnabled = valueScheduledTasksScheduledTask["TaskEnabled"].asString() == "true";
if(!valueScheduledTasksScheduledTask["MaxValue"].isNull())
scheduledTasksObject.maxValue = std::stoi(valueScheduledTasksScheduledTask["MaxValue"].asString());
if(!valueScheduledTasksScheduledTask["MinValue"].isNull())
scheduledTasksObject.minValue = std::stoi(valueScheduledTasksScheduledTask["MinValue"].asString());
scheduledTasks_.push_back(scheduledTasksObject);
}
if(!value["TotalCount"].isNull())