From ec6303fa646e4a414e73d58d83052030fb16562f Mon Sep 17 00:00:00 2001 From: sdk-team Date: Fri, 7 Jan 2022 06:22:43 +0000 Subject: [PATCH] Supported minReadyInstanceRatio parameter for deploy. --- CHANGELOG | 3 + VERSION | 2 +- sae/CMakeLists.txt | 4 + sae/include/alibabacloud/sae/SaeClient.h | 8 + .../CreateApplicationScalingRuleRequest.h | 9 +- .../sae/model/DeployApplicationRequest.h | 3 + .../model/DescribeApplicationConfigResult.h | 1 + .../DescribeApplicationScalingRuleRequest.h | 51 ++++++ .../DescribeApplicationScalingRuleResult.h | 124 +++++++++++++++ .../sae/model/RescaleApplicationRequest.h | 3 + .../sae/model/RestartApplicationRequest.h | 3 + .../sae/model/RollbackApplicationRequest.h | 3 + .../UpdateApplicationScalingRuleRequest.h | 9 +- .../UpdateApplicationScalingRuleResult.h | 2 +- sae/src/SaeClient.cc | 36 +++++ .../CreateApplicationScalingRuleRequest.cc | 17 +- sae/src/model/DeployApplicationRequest.cc | 11 ++ .../model/DescribeApplicationConfigResult.cc | 2 + .../DescribeApplicationScalingRuleRequest.cc | 52 ++++++ .../DescribeApplicationScalingRuleResult.cc | 150 ++++++++++++++++++ sae/src/model/RescaleApplicationRequest.cc | 11 ++ sae/src/model/RestartApplicationRequest.cc | 11 ++ sae/src/model/RollbackApplicationRequest.cc | 11 ++ .../UpdateApplicationScalingRuleRequest.cc | 17 +- .../UpdateApplicationScalingRuleResult.cc | 32 ++-- 25 files changed, 545 insertions(+), 30 deletions(-) create mode 100644 sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleRequest.h create mode 100644 sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleResult.h create mode 100644 sae/src/model/DescribeApplicationScalingRuleRequest.cc create mode 100644 sae/src/model/DescribeApplicationScalingRuleResult.cc diff --git a/CHANGELOG b/CHANGELOG index 25f76e6da..283588c49 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2022-01-07 Version: 1.36.1015 +- Supported minReadyInstanceRatio parameter for deploy. + 2022-01-07 Version: 1.36.1014 - Support New API for Dypnsapi. diff --git a/VERSION b/VERSION index d512bd21c..81c89afb8 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1014 \ No newline at end of file +1.36.1015 \ No newline at end of file diff --git a/sae/CMakeLists.txt b/sae/CMakeLists.txt index 9f9e459f0..dd95f3ffb 100644 --- a/sae/CMakeLists.txt +++ b/sae/CMakeLists.txt @@ -69,6 +69,8 @@ set(sae_public_header_model include/alibabacloud/sae/model/DescribeApplicationImageResult.h include/alibabacloud/sae/model/DescribeApplicationInstancesRequest.h include/alibabacloud/sae/model/DescribeApplicationInstancesResult.h + include/alibabacloud/sae/model/DescribeApplicationScalingRuleRequest.h + include/alibabacloud/sae/model/DescribeApplicationScalingRuleResult.h include/alibabacloud/sae/model/DescribeApplicationScalingRulesRequest.h include/alibabacloud/sae/model/DescribeApplicationScalingRulesResult.h include/alibabacloud/sae/model/DescribeApplicationSlbsRequest.h @@ -228,6 +230,8 @@ set(sae_src src/model/DescribeApplicationImageResult.cc src/model/DescribeApplicationInstancesRequest.cc src/model/DescribeApplicationInstancesResult.cc + src/model/DescribeApplicationScalingRuleRequest.cc + src/model/DescribeApplicationScalingRuleResult.cc src/model/DescribeApplicationScalingRulesRequest.cc src/model/DescribeApplicationScalingRulesResult.cc src/model/DescribeApplicationSlbsRequest.cc diff --git a/sae/include/alibabacloud/sae/SaeClient.h b/sae/include/alibabacloud/sae/SaeClient.h index 18cde7f8a..fb4c4e01d 100644 --- a/sae/include/alibabacloud/sae/SaeClient.h +++ b/sae/include/alibabacloud/sae/SaeClient.h @@ -70,6 +70,8 @@ #include "model/DescribeApplicationImageResult.h" #include "model/DescribeApplicationInstancesRequest.h" #include "model/DescribeApplicationInstancesResult.h" +#include "model/DescribeApplicationScalingRuleRequest.h" +#include "model/DescribeApplicationScalingRuleResult.h" #include "model/DescribeApplicationScalingRulesRequest.h" #include "model/DescribeApplicationScalingRulesResult.h" #include "model/DescribeApplicationSlbsRequest.h" @@ -259,6 +261,9 @@ namespace AlibabaCloud typedef Outcome DescribeApplicationInstancesOutcome; typedef std::future DescribeApplicationInstancesOutcomeCallable; typedef std::function&)> DescribeApplicationInstancesAsyncHandler; + typedef Outcome DescribeApplicationScalingRuleOutcome; + typedef std::future DescribeApplicationScalingRuleOutcomeCallable; + typedef std::function&)> DescribeApplicationScalingRuleAsyncHandler; typedef Outcome DescribeApplicationScalingRulesOutcome; typedef std::future DescribeApplicationScalingRulesOutcomeCallable; typedef std::function&)> DescribeApplicationScalingRulesAsyncHandler; @@ -498,6 +503,9 @@ namespace AlibabaCloud DescribeApplicationInstancesOutcome describeApplicationInstances(const Model::DescribeApplicationInstancesRequest &request)const; void describeApplicationInstancesAsync(const Model::DescribeApplicationInstancesRequest& request, const DescribeApplicationInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeApplicationInstancesOutcomeCallable describeApplicationInstancesCallable(const Model::DescribeApplicationInstancesRequest& request) const; + DescribeApplicationScalingRuleOutcome describeApplicationScalingRule(const Model::DescribeApplicationScalingRuleRequest &request)const; + void describeApplicationScalingRuleAsync(const Model::DescribeApplicationScalingRuleRequest& request, const DescribeApplicationScalingRuleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeApplicationScalingRuleOutcomeCallable describeApplicationScalingRuleCallable(const Model::DescribeApplicationScalingRuleRequest& request) const; DescribeApplicationScalingRulesOutcome describeApplicationScalingRules(const Model::DescribeApplicationScalingRulesRequest &request)const; void describeApplicationScalingRulesAsync(const Model::DescribeApplicationScalingRulesRequest& request, const DescribeApplicationScalingRulesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeApplicationScalingRulesOutcomeCallable describeApplicationScalingRulesCallable(const Model::DescribeApplicationScalingRulesRequest& request) const; diff --git a/sae/include/alibabacloud/sae/model/CreateApplicationScalingRuleRequest.h b/sae/include/alibabacloud/sae/model/CreateApplicationScalingRuleRequest.h index 4b62340d4..7a9b905b8 100644 --- a/sae/include/alibabacloud/sae/model/CreateApplicationScalingRuleRequest.h +++ b/sae/include/alibabacloud/sae/model/CreateApplicationScalingRuleRequest.h @@ -37,8 +37,8 @@ namespace AlibabaCloud std::string getScalingRuleName()const; void setScalingRuleName(const std::string& scalingRuleName); - std::string getMinReadyInstances()const; - void setMinReadyInstances(const std::string& minReadyInstances); + int getMinReadyInstances()const; + void setMinReadyInstances(int minReadyInstances); bool getScalingRuleEnable()const; void setScalingRuleEnable(bool scalingRuleEnable); std::string getScalingRuleTimer()const; @@ -47,16 +47,19 @@ namespace AlibabaCloud void setScalingRuleMetric(const std::string& scalingRuleMetric); std::string getAppId()const; void setAppId(const std::string& appId); + int getMinReadyInstanceRatio()const; + void setMinReadyInstanceRatio(int minReadyInstanceRatio); std::string getScalingRuleType()const; void setScalingRuleType(const std::string& scalingRuleType); private: std::string scalingRuleName_; - std::string minReadyInstances_; + int minReadyInstances_; bool scalingRuleEnable_; std::string scalingRuleTimer_; std::string scalingRuleMetric_; std::string appId_; + int minReadyInstanceRatio_; std::string scalingRuleType_; }; diff --git a/sae/include/alibabacloud/sae/model/DeployApplicationRequest.h b/sae/include/alibabacloud/sae/model/DeployApplicationRequest.h index 51cc13f3e..da5bf46e9 100644 --- a/sae/include/alibabacloud/sae/model/DeployApplicationRequest.h +++ b/sae/include/alibabacloud/sae/model/DeployApplicationRequest.h @@ -113,6 +113,8 @@ namespace AlibabaCloud void setAppId(const std::string& appId); std::string getImageUrl()const; void setImageUrl(const std::string& imageUrl); + int getMinReadyInstanceRatio()const; + void setMinReadyInstanceRatio(int minReadyInstanceRatio); std::string getPhp()const; void setPhp(const std::string& php); bool getAutoEnableApplicationScalingRule()const; @@ -166,6 +168,7 @@ namespace AlibabaCloud std::string acrInstanceId_; std::string appId_; std::string imageUrl_; + int minReadyInstanceRatio_; std::string php_; bool autoEnableApplicationScalingRule_; std::string phpConfigLocation_; diff --git a/sae/include/alibabacloud/sae/model/DescribeApplicationConfigResult.h b/sae/include/alibabacloud/sae/model/DescribeApplicationConfigResult.h index 35eeadfea..3f4fcd8f7 100644 --- a/sae/include/alibabacloud/sae/model/DescribeApplicationConfigResult.h +++ b/sae/include/alibabacloud/sae/model/DescribeApplicationConfigResult.h @@ -111,6 +111,7 @@ namespace AlibabaCloud std::string packageUrl; std::string phpConfigLocation; int batchWaitTime; + int minReadyInstanceRatio; std::string phpPECLExtensions; std::string regionId; std::string enableAhas; diff --git a/sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleRequest.h b/sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleRequest.h new file mode 100644 index 000000000..1ff0abad2 --- /dev/null +++ b/sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleRequest.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_SAE_MODEL_DESCRIBEAPPLICATIONSCALINGRULEREQUEST_H_ +#define ALIBABACLOUD_SAE_MODEL_DESCRIBEAPPLICATIONSCALINGRULEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Sae + { + namespace Model + { + class ALIBABACLOUD_SAE_EXPORT DescribeApplicationScalingRuleRequest : public RoaServiceRequest + { + + public: + DescribeApplicationScalingRuleRequest(); + ~DescribeApplicationScalingRuleRequest(); + + std::string getScalingRuleName()const; + void setScalingRuleName(const std::string& scalingRuleName); + std::string getAppId()const; + void setAppId(const std::string& appId); + + private: + std::string scalingRuleName_; + std::string appId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SAE_MODEL_DESCRIBEAPPLICATIONSCALINGRULEREQUEST_H_ \ No newline at end of file diff --git a/sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleResult.h b/sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleResult.h new file mode 100644 index 000000000..476040272 --- /dev/null +++ b/sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleResult.h @@ -0,0 +1,124 @@ +/* + * 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_SAE_MODEL_DESCRIBEAPPLICATIONSCALINGRULERESULT_H_ +#define ALIBABACLOUD_SAE_MODEL_DESCRIBEAPPLICATIONSCALINGRULERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Sae + { + namespace Model + { + class ALIBABACLOUD_SAE_EXPORT DescribeApplicationScalingRuleResult : public ServiceResult + { + public: + struct Data + { + struct Timer + { + struct Schedule + { + int targetReplicas; + std::string atTime; + }; + std::vector schedules; + std::string period; + std::string endDate; + std::string beginDate; + }; + struct Metric + { + struct MetricsStatus + { + struct CurrentMetric + { + std::string type; + long currentValue; + std::string name; + }; + struct NextScaleMetric + { + int nextScaleInAverageUtilization; + int nextScaleOutAverageUtilization; + std::string name; + }; + std::vector nextScaleMetrics; + long desiredReplicas; + std::vector currentMetrics; + long currentReplicas; + int nextScaleTimePeriod; + std::string lastScaleTime; + }; + struct ScaleUpRules + { + long step; + long stabilizationWindowSeconds; + bool disabled; + }; + struct ScaleDownRules + { + long step; + long stabilizationWindowSeconds; + bool disabled; + }; + struct Metric1 + { + std::string metricType; + int metricTargetAverageUtilization; + }; + std::vector metrics; + int minReplicas; + ScaleDownRules scaleDownRules; + int maxReplicas; + MetricsStatus metricsStatus; + ScaleUpRules scaleUpRules; + }; + bool scaleRuleEnabled; + Timer timer; + std::string appId; + long lastDisableTime; + long createTime; + long updateTime; + Metric metric; + std::string scaleRuleName; + std::string scaleRuleType; + }; + + + DescribeApplicationScalingRuleResult(); + explicit DescribeApplicationScalingRuleResult(const std::string &payload); + ~DescribeApplicationScalingRuleResult(); + std::string getTraceId()const; + Data getData()const; + + protected: + void parse(const std::string &payload); + private: + std::string traceId_; + Data data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SAE_MODEL_DESCRIBEAPPLICATIONSCALINGRULERESULT_H_ \ No newline at end of file diff --git a/sae/include/alibabacloud/sae/model/RescaleApplicationRequest.h b/sae/include/alibabacloud/sae/model/RescaleApplicationRequest.h index f3b4d8fe8..8b2f42c25 100644 --- a/sae/include/alibabacloud/sae/model/RescaleApplicationRequest.h +++ b/sae/include/alibabacloud/sae/model/RescaleApplicationRequest.h @@ -41,6 +41,8 @@ namespace AlibabaCloud void setReplicas(int replicas); std::string getAppId()const; void setAppId(const std::string& appId); + int getMinReadyInstanceRatio()const; + void setMinReadyInstanceRatio(int minReadyInstanceRatio); bool getAutoEnableApplicationScalingRule()const; void setAutoEnableApplicationScalingRule(bool autoEnableApplicationScalingRule); @@ -48,6 +50,7 @@ namespace AlibabaCloud int minReadyInstances_; int replicas_; std::string appId_; + int minReadyInstanceRatio_; bool autoEnableApplicationScalingRule_; }; diff --git a/sae/include/alibabacloud/sae/model/RestartApplicationRequest.h b/sae/include/alibabacloud/sae/model/RestartApplicationRequest.h index 9b53d3b35..db35bab96 100644 --- a/sae/include/alibabacloud/sae/model/RestartApplicationRequest.h +++ b/sae/include/alibabacloud/sae/model/RestartApplicationRequest.h @@ -39,10 +39,13 @@ namespace AlibabaCloud void setMinReadyInstances(int minReadyInstances); std::string getAppId()const; void setAppId(const std::string& appId); + int getMinReadyInstanceRatio()const; + void setMinReadyInstanceRatio(int minReadyInstanceRatio); private: int minReadyInstances_; std::string appId_; + int minReadyInstanceRatio_; }; } diff --git a/sae/include/alibabacloud/sae/model/RollbackApplicationRequest.h b/sae/include/alibabacloud/sae/model/RollbackApplicationRequest.h index 18b6b733e..0125f524e 100644 --- a/sae/include/alibabacloud/sae/model/RollbackApplicationRequest.h +++ b/sae/include/alibabacloud/sae/model/RollbackApplicationRequest.h @@ -43,6 +43,8 @@ namespace AlibabaCloud void setAppId(const std::string& appId); int getBatchWaitTime()const; void setBatchWaitTime(int batchWaitTime); + int getMinReadyInstanceRatio()const; + void setMinReadyInstanceRatio(int minReadyInstanceRatio); std::string getAutoEnableApplicationScalingRule()const; void setAutoEnableApplicationScalingRule(const std::string& autoEnableApplicationScalingRule); std::string getUpdateStrategy()const; @@ -53,6 +55,7 @@ namespace AlibabaCloud std::string versionId_; std::string appId_; int batchWaitTime_; + int minReadyInstanceRatio_; std::string autoEnableApplicationScalingRule_; std::string updateStrategy_; diff --git a/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleRequest.h b/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleRequest.h index a4538b3d6..6006e383d 100644 --- a/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleRequest.h +++ b/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleRequest.h @@ -37,21 +37,24 @@ namespace AlibabaCloud std::string getScalingRuleName()const; void setScalingRuleName(const std::string& scalingRuleName); - std::string getMinReadyInstances()const; - void setMinReadyInstances(const std::string& minReadyInstances); + int getMinReadyInstances()const; + void setMinReadyInstances(int minReadyInstances); std::string getScalingRuleTimer()const; void setScalingRuleTimer(const std::string& scalingRuleTimer); std::string getScalingRuleMetric()const; void setScalingRuleMetric(const std::string& scalingRuleMetric); std::string getAppId()const; void setAppId(const std::string& appId); + int getMinReadyInstanceRatio()const; + void setMinReadyInstanceRatio(int minReadyInstanceRatio); private: std::string scalingRuleName_; - std::string minReadyInstances_; + int minReadyInstances_; std::string scalingRuleTimer_; std::string scalingRuleMetric_; std::string appId_; + int minReadyInstanceRatio_; }; } diff --git a/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleResult.h b/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleResult.h index 19aa8590c..94e49f09b 100644 --- a/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleResult.h +++ b/sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleResult.h @@ -59,8 +59,8 @@ namespace AlibabaCloud }; bool scaleRuleEnabled; Timer timer; - long lastDisableTime; std::string appId; + long lastDisableTime; long createTime; long updateTime; Metric metric; diff --git a/sae/src/SaeClient.cc b/sae/src/SaeClient.cc index c79d3c8db..8c51aef47 100644 --- a/sae/src/SaeClient.cc +++ b/sae/src/SaeClient.cc @@ -915,6 +915,42 @@ SaeClient::DescribeApplicationInstancesOutcomeCallable SaeClient::describeApplic return task->get_future(); } +SaeClient::DescribeApplicationScalingRuleOutcome SaeClient::describeApplicationScalingRule(const DescribeApplicationScalingRuleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeApplicationScalingRuleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeApplicationScalingRuleOutcome(DescribeApplicationScalingRuleResult(outcome.result())); + else + return DescribeApplicationScalingRuleOutcome(outcome.error()); +} + +void SaeClient::describeApplicationScalingRuleAsync(const DescribeApplicationScalingRuleRequest& request, const DescribeApplicationScalingRuleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeApplicationScalingRule(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SaeClient::DescribeApplicationScalingRuleOutcomeCallable SaeClient::describeApplicationScalingRuleCallable(const DescribeApplicationScalingRuleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeApplicationScalingRule(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + SaeClient::DescribeApplicationScalingRulesOutcome SaeClient::describeApplicationScalingRules(const DescribeApplicationScalingRulesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/sae/src/model/CreateApplicationScalingRuleRequest.cc b/sae/src/model/CreateApplicationScalingRuleRequest.cc index 401be81ee..f4c712976 100644 --- a/sae/src/model/CreateApplicationScalingRuleRequest.cc +++ b/sae/src/model/CreateApplicationScalingRuleRequest.cc @@ -39,15 +39,15 @@ void CreateApplicationScalingRuleRequest::setScalingRuleName(const std::string& setParameter("ScalingRuleName", scalingRuleName); } -std::string CreateApplicationScalingRuleRequest::getMinReadyInstances()const +int CreateApplicationScalingRuleRequest::getMinReadyInstances()const { return minReadyInstances_; } -void CreateApplicationScalingRuleRequest::setMinReadyInstances(const std::string& minReadyInstances) +void CreateApplicationScalingRuleRequest::setMinReadyInstances(int minReadyInstances) { minReadyInstances_ = minReadyInstances; - setParameter("MinReadyInstances", minReadyInstances); + setParameter("MinReadyInstances", std::to_string(minReadyInstances)); } bool CreateApplicationScalingRuleRequest::getScalingRuleEnable()const @@ -94,6 +94,17 @@ void CreateApplicationScalingRuleRequest::setAppId(const std::string& appId) setParameter("AppId", appId); } +int CreateApplicationScalingRuleRequest::getMinReadyInstanceRatio()const +{ + return minReadyInstanceRatio_; +} + +void CreateApplicationScalingRuleRequest::setMinReadyInstanceRatio(int minReadyInstanceRatio) +{ + minReadyInstanceRatio_ = minReadyInstanceRatio; + setParameter("MinReadyInstanceRatio", std::to_string(minReadyInstanceRatio)); +} + std::string CreateApplicationScalingRuleRequest::getScalingRuleType()const { return scalingRuleType_; diff --git a/sae/src/model/DeployApplicationRequest.cc b/sae/src/model/DeployApplicationRequest.cc index 1fc1d874d..137fec2aa 100644 --- a/sae/src/model/DeployApplicationRequest.cc +++ b/sae/src/model/DeployApplicationRequest.cc @@ -457,6 +457,17 @@ void DeployApplicationRequest::setImageUrl(const std::string& imageUrl) setParameter("ImageUrl", imageUrl); } +int DeployApplicationRequest::getMinReadyInstanceRatio()const +{ + return minReadyInstanceRatio_; +} + +void DeployApplicationRequest::setMinReadyInstanceRatio(int minReadyInstanceRatio) +{ + minReadyInstanceRatio_ = minReadyInstanceRatio; + setParameter("MinReadyInstanceRatio", std::to_string(minReadyInstanceRatio)); +} + std::string DeployApplicationRequest::getPhp()const { return php_; diff --git a/sae/src/model/DescribeApplicationConfigResult.cc b/sae/src/model/DescribeApplicationConfigResult.cc index 9e56276b8..32ee42465 100644 --- a/sae/src/model/DescribeApplicationConfigResult.cc +++ b/sae/src/model/DescribeApplicationConfigResult.cc @@ -78,6 +78,8 @@ void DescribeApplicationConfigResult::parse(const std::string &payload) data_.updateStrategy = dataNode["UpdateStrategy"].asString(); if(!dataNode["MinReadyInstances"].isNull()) data_.minReadyInstances = std::stoi(dataNode["MinReadyInstances"].asString()); + if(!dataNode["MinReadyInstanceRatio"].isNull()) + data_.minReadyInstanceRatio = std::stoi(dataNode["MinReadyInstanceRatio"].asString()); if(!dataNode["Memory"].isNull()) data_.memory = std::stoi(dataNode["Memory"].asString()); if(!dataNode["Php"].isNull()) diff --git a/sae/src/model/DescribeApplicationScalingRuleRequest.cc b/sae/src/model/DescribeApplicationScalingRuleRequest.cc new file mode 100644 index 000000000..4f6b69c4c --- /dev/null +++ b/sae/src/model/DescribeApplicationScalingRuleRequest.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 + +using AlibabaCloud::Sae::Model::DescribeApplicationScalingRuleRequest; + +DescribeApplicationScalingRuleRequest::DescribeApplicationScalingRuleRequest() : + RoaServiceRequest("sae", "2019-05-06") +{ + setResourcePath("/pop/v1/sam/scale/applicationScalingRule"); + setMethod(HttpRequest::Method::Get); +} + +DescribeApplicationScalingRuleRequest::~DescribeApplicationScalingRuleRequest() +{} + +std::string DescribeApplicationScalingRuleRequest::getScalingRuleName()const +{ + return scalingRuleName_; +} + +void DescribeApplicationScalingRuleRequest::setScalingRuleName(const std::string& scalingRuleName) +{ + scalingRuleName_ = scalingRuleName; + setParameter("ScalingRuleName", scalingRuleName); +} + +std::string DescribeApplicationScalingRuleRequest::getAppId()const +{ + return appId_; +} + +void DescribeApplicationScalingRuleRequest::setAppId(const std::string& appId) +{ + appId_ = appId; + setParameter("AppId", appId); +} + diff --git a/sae/src/model/DescribeApplicationScalingRuleResult.cc b/sae/src/model/DescribeApplicationScalingRuleResult.cc new file mode 100644 index 000000000..7ed6db86d --- /dev/null +++ b/sae/src/model/DescribeApplicationScalingRuleResult.cc @@ -0,0 +1,150 @@ +/* + * 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::Sae; +using namespace AlibabaCloud::Sae::Model; + +DescribeApplicationScalingRuleResult::DescribeApplicationScalingRuleResult() : + ServiceResult() +{} + +DescribeApplicationScalingRuleResult::DescribeApplicationScalingRuleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeApplicationScalingRuleResult::~DescribeApplicationScalingRuleResult() +{} + +void DescribeApplicationScalingRuleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["UpdateTime"].isNull()) + data_.updateTime = std::stol(dataNode["UpdateTime"].asString()); + if(!dataNode["AppId"].isNull()) + data_.appId = dataNode["AppId"].asString(); + if(!dataNode["CreateTime"].isNull()) + data_.createTime = std::stol(dataNode["CreateTime"].asString()); + if(!dataNode["LastDisableTime"].isNull()) + data_.lastDisableTime = std::stol(dataNode["LastDisableTime"].asString()); + if(!dataNode["ScaleRuleEnabled"].isNull()) + data_.scaleRuleEnabled = dataNode["ScaleRuleEnabled"].asString() == "true"; + if(!dataNode["ScaleRuleType"].isNull()) + data_.scaleRuleType = dataNode["ScaleRuleType"].asString(); + if(!dataNode["ScaleRuleName"].isNull()) + data_.scaleRuleName = dataNode["ScaleRuleName"].asString(); + auto timerNode = dataNode["Timer"]; + if(!timerNode["EndDate"].isNull()) + data_.timer.endDate = timerNode["EndDate"].asString(); + if(!timerNode["BeginDate"].isNull()) + data_.timer.beginDate = timerNode["BeginDate"].asString(); + if(!timerNode["Period"].isNull()) + data_.timer.period = timerNode["Period"].asString(); + auto allSchedulesNode = timerNode["Schedules"]["Schedule"]; + for (auto timerNodeSchedulesSchedule : allSchedulesNode) + { + Data::Timer::Schedule scheduleObject; + if(!timerNodeSchedulesSchedule["AtTime"].isNull()) + scheduleObject.atTime = timerNodeSchedulesSchedule["AtTime"].asString(); + if(!timerNodeSchedulesSchedule["TargetReplicas"].isNull()) + scheduleObject.targetReplicas = std::stoi(timerNodeSchedulesSchedule["TargetReplicas"].asString()); + data_.timer.schedules.push_back(scheduleObject); + } + auto metricNode = dataNode["Metric"]; + if(!metricNode["MaxReplicas"].isNull()) + data_.metric.maxReplicas = std::stoi(metricNode["MaxReplicas"].asString()); + if(!metricNode["MinReplicas"].isNull()) + data_.metric.minReplicas = std::stoi(metricNode["MinReplicas"].asString()); + auto allMetricsNode = metricNode["Metrics"]["Metric"]; + for (auto metricNodeMetricsMetric : allMetricsNode) + { + Data::Metric::Metric1 metric1Object; + if(!metricNodeMetricsMetric["MetricTargetAverageUtilization"].isNull()) + metric1Object.metricTargetAverageUtilization = std::stoi(metricNodeMetricsMetric["MetricTargetAverageUtilization"].asString()); + if(!metricNodeMetricsMetric["MetricType"].isNull()) + metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString(); + data_.metric.metrics.push_back(metric1Object); + } + auto metricsStatusNode = metricNode["MetricsStatus"]; + if(!metricsStatusNode["DesiredReplicas"].isNull()) + data_.metric.metricsStatus.desiredReplicas = std::stol(metricsStatusNode["DesiredReplicas"].asString()); + if(!metricsStatusNode["NextScaleTimePeriod"].isNull()) + data_.metric.metricsStatus.nextScaleTimePeriod = std::stoi(metricsStatusNode["NextScaleTimePeriod"].asString()); + if(!metricsStatusNode["CurrentReplicas"].isNull()) + data_.metric.metricsStatus.currentReplicas = std::stol(metricsStatusNode["CurrentReplicas"].asString()); + if(!metricsStatusNode["LastScaleTime"].isNull()) + data_.metric.metricsStatus.lastScaleTime = metricsStatusNode["LastScaleTime"].asString(); + auto allCurrentMetricsNode = metricsStatusNode["CurrentMetrics"]["CurrentMetric"]; + for (auto metricsStatusNodeCurrentMetricsCurrentMetric : allCurrentMetricsNode) + { + Data::Metric::MetricsStatus::CurrentMetric currentMetricObject; + if(!metricsStatusNodeCurrentMetricsCurrentMetric["Type"].isNull()) + currentMetricObject.type = metricsStatusNodeCurrentMetricsCurrentMetric["Type"].asString(); + if(!metricsStatusNodeCurrentMetricsCurrentMetric["CurrentValue"].isNull()) + currentMetricObject.currentValue = std::stol(metricsStatusNodeCurrentMetricsCurrentMetric["CurrentValue"].asString()); + if(!metricsStatusNodeCurrentMetricsCurrentMetric["Name"].isNull()) + currentMetricObject.name = metricsStatusNodeCurrentMetricsCurrentMetric["Name"].asString(); + data_.metric.metricsStatus.currentMetrics.push_back(currentMetricObject); + } + auto allNextScaleMetricsNode = metricsStatusNode["NextScaleMetrics"]["NextScaleMetric"]; + for (auto metricsStatusNodeNextScaleMetricsNextScaleMetric : allNextScaleMetricsNode) + { + Data::Metric::MetricsStatus::NextScaleMetric nextScaleMetricObject; + if(!metricsStatusNodeNextScaleMetricsNextScaleMetric["NextScaleOutAverageUtilization"].isNull()) + nextScaleMetricObject.nextScaleOutAverageUtilization = std::stoi(metricsStatusNodeNextScaleMetricsNextScaleMetric["NextScaleOutAverageUtilization"].asString()); + if(!metricsStatusNodeNextScaleMetricsNextScaleMetric["NextScaleInAverageUtilization"].isNull()) + nextScaleMetricObject.nextScaleInAverageUtilization = std::stoi(metricsStatusNodeNextScaleMetricsNextScaleMetric["NextScaleInAverageUtilization"].asString()); + if(!metricsStatusNodeNextScaleMetricsNextScaleMetric["Name"].isNull()) + nextScaleMetricObject.name = metricsStatusNodeNextScaleMetricsNextScaleMetric["Name"].asString(); + data_.metric.metricsStatus.nextScaleMetrics.push_back(nextScaleMetricObject); + } + auto scaleUpRulesNode = metricNode["ScaleUpRules"]; + if(!scaleUpRulesNode["Step"].isNull()) + data_.metric.scaleUpRules.step = std::stol(scaleUpRulesNode["Step"].asString()); + if(!scaleUpRulesNode["StabilizationWindowSeconds"].isNull()) + data_.metric.scaleUpRules.stabilizationWindowSeconds = std::stol(scaleUpRulesNode["StabilizationWindowSeconds"].asString()); + if(!scaleUpRulesNode["Disabled"].isNull()) + data_.metric.scaleUpRules.disabled = scaleUpRulesNode["Disabled"].asString() == "true"; + auto scaleDownRulesNode = metricNode["ScaleDownRules"]; + if(!scaleDownRulesNode["Step"].isNull()) + data_.metric.scaleDownRules.step = std::stol(scaleDownRulesNode["Step"].asString()); + if(!scaleDownRulesNode["StabilizationWindowSeconds"].isNull()) + data_.metric.scaleDownRules.stabilizationWindowSeconds = std::stol(scaleDownRulesNode["StabilizationWindowSeconds"].asString()); + if(!scaleDownRulesNode["Disabled"].isNull()) + data_.metric.scaleDownRules.disabled = scaleDownRulesNode["Disabled"].asString() == "true"; + if(!value["TraceId"].isNull()) + traceId_ = value["TraceId"].asString(); + +} + +std::string DescribeApplicationScalingRuleResult::getTraceId()const +{ + return traceId_; +} + +DescribeApplicationScalingRuleResult::Data DescribeApplicationScalingRuleResult::getData()const +{ + return data_; +} + diff --git a/sae/src/model/RescaleApplicationRequest.cc b/sae/src/model/RescaleApplicationRequest.cc index 98fd416db..e4526b301 100644 --- a/sae/src/model/RescaleApplicationRequest.cc +++ b/sae/src/model/RescaleApplicationRequest.cc @@ -61,6 +61,17 @@ void RescaleApplicationRequest::setAppId(const std::string& appId) setParameter("AppId", appId); } +int RescaleApplicationRequest::getMinReadyInstanceRatio()const +{ + return minReadyInstanceRatio_; +} + +void RescaleApplicationRequest::setMinReadyInstanceRatio(int minReadyInstanceRatio) +{ + minReadyInstanceRatio_ = minReadyInstanceRatio; + setParameter("MinReadyInstanceRatio", std::to_string(minReadyInstanceRatio)); +} + bool RescaleApplicationRequest::getAutoEnableApplicationScalingRule()const { return autoEnableApplicationScalingRule_; diff --git a/sae/src/model/RestartApplicationRequest.cc b/sae/src/model/RestartApplicationRequest.cc index c140d45ce..83080824e 100644 --- a/sae/src/model/RestartApplicationRequest.cc +++ b/sae/src/model/RestartApplicationRequest.cc @@ -50,3 +50,14 @@ void RestartApplicationRequest::setAppId(const std::string& appId) setParameter("AppId", appId); } +int RestartApplicationRequest::getMinReadyInstanceRatio()const +{ + return minReadyInstanceRatio_; +} + +void RestartApplicationRequest::setMinReadyInstanceRatio(int minReadyInstanceRatio) +{ + minReadyInstanceRatio_ = minReadyInstanceRatio; + setParameter("MinReadyInstanceRatio", std::to_string(minReadyInstanceRatio)); +} + diff --git a/sae/src/model/RollbackApplicationRequest.cc b/sae/src/model/RollbackApplicationRequest.cc index ab60daec5..960eaf515 100644 --- a/sae/src/model/RollbackApplicationRequest.cc +++ b/sae/src/model/RollbackApplicationRequest.cc @@ -72,6 +72,17 @@ void RollbackApplicationRequest::setBatchWaitTime(int batchWaitTime) setParameter("BatchWaitTime", std::to_string(batchWaitTime)); } +int RollbackApplicationRequest::getMinReadyInstanceRatio()const +{ + return minReadyInstanceRatio_; +} + +void RollbackApplicationRequest::setMinReadyInstanceRatio(int minReadyInstanceRatio) +{ + minReadyInstanceRatio_ = minReadyInstanceRatio; + setParameter("MinReadyInstanceRatio", std::to_string(minReadyInstanceRatio)); +} + std::string RollbackApplicationRequest::getAutoEnableApplicationScalingRule()const { return autoEnableApplicationScalingRule_; diff --git a/sae/src/model/UpdateApplicationScalingRuleRequest.cc b/sae/src/model/UpdateApplicationScalingRuleRequest.cc index a3def420b..6a2cd7039 100644 --- a/sae/src/model/UpdateApplicationScalingRuleRequest.cc +++ b/sae/src/model/UpdateApplicationScalingRuleRequest.cc @@ -39,15 +39,15 @@ void UpdateApplicationScalingRuleRequest::setScalingRuleName(const std::string& setParameter("ScalingRuleName", scalingRuleName); } -std::string UpdateApplicationScalingRuleRequest::getMinReadyInstances()const +int UpdateApplicationScalingRuleRequest::getMinReadyInstances()const { return minReadyInstances_; } -void UpdateApplicationScalingRuleRequest::setMinReadyInstances(const std::string& minReadyInstances) +void UpdateApplicationScalingRuleRequest::setMinReadyInstances(int minReadyInstances) { minReadyInstances_ = minReadyInstances; - setParameter("MinReadyInstances", minReadyInstances); + setParameter("MinReadyInstances", std::to_string(minReadyInstances)); } std::string UpdateApplicationScalingRuleRequest::getScalingRuleTimer()const @@ -83,3 +83,14 @@ void UpdateApplicationScalingRuleRequest::setAppId(const std::string& appId) setParameter("AppId", appId); } +int UpdateApplicationScalingRuleRequest::getMinReadyInstanceRatio()const +{ + return minReadyInstanceRatio_; +} + +void UpdateApplicationScalingRuleRequest::setMinReadyInstanceRatio(int minReadyInstanceRatio) +{ + minReadyInstanceRatio_ = minReadyInstanceRatio; + setParameter("MinReadyInstanceRatio", std::to_string(minReadyInstanceRatio)); +} + diff --git a/sae/src/model/UpdateApplicationScalingRuleResult.cc b/sae/src/model/UpdateApplicationScalingRuleResult.cc index 73f4613a5..2a9540d22 100644 --- a/sae/src/model/UpdateApplicationScalingRuleResult.cc +++ b/sae/src/model/UpdateApplicationScalingRuleResult.cc @@ -40,50 +40,50 @@ void UpdateApplicationScalingRuleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["ScaleRuleEnabled"].isNull()) - data_.scaleRuleEnabled = dataNode["ScaleRuleEnabled"].asString() == "true"; - if(!dataNode["LastDisableTime"].isNull()) - data_.lastDisableTime = std::stol(dataNode["LastDisableTime"].asString()); + if(!dataNode["UpdateTime"].isNull()) + data_.updateTime = std::stol(dataNode["UpdateTime"].asString()); if(!dataNode["AppId"].isNull()) data_.appId = dataNode["AppId"].asString(); if(!dataNode["CreateTime"].isNull()) data_.createTime = std::stol(dataNode["CreateTime"].asString()); - if(!dataNode["UpdateTime"].isNull()) - data_.updateTime = std::stol(dataNode["UpdateTime"].asString()); - if(!dataNode["ScaleRuleName"].isNull()) - data_.scaleRuleName = dataNode["ScaleRuleName"].asString(); + if(!dataNode["LastDisableTime"].isNull()) + data_.lastDisableTime = std::stol(dataNode["LastDisableTime"].asString()); + if(!dataNode["ScaleRuleEnabled"].isNull()) + data_.scaleRuleEnabled = dataNode["ScaleRuleEnabled"].asString() == "true"; if(!dataNode["ScaleRuleType"].isNull()) data_.scaleRuleType = dataNode["ScaleRuleType"].asString(); + if(!dataNode["ScaleRuleName"].isNull()) + data_.scaleRuleName = dataNode["ScaleRuleName"].asString(); auto timerNode = dataNode["Timer"]; - if(!timerNode["Period"].isNull()) - data_.timer.period = timerNode["Period"].asString(); if(!timerNode["EndDate"].isNull()) data_.timer.endDate = timerNode["EndDate"].asString(); if(!timerNode["BeginDate"].isNull()) data_.timer.beginDate = timerNode["BeginDate"].asString(); + if(!timerNode["Period"].isNull()) + data_.timer.period = timerNode["Period"].asString(); auto allSchedulesNode = timerNode["Schedules"]["Schedule"]; for (auto timerNodeSchedulesSchedule : allSchedulesNode) { Data::Timer::Schedule scheduleObject; - if(!timerNodeSchedulesSchedule["TargetReplicas"].isNull()) - scheduleObject.targetReplicas = std::stoi(timerNodeSchedulesSchedule["TargetReplicas"].asString()); if(!timerNodeSchedulesSchedule["AtTime"].isNull()) scheduleObject.atTime = timerNodeSchedulesSchedule["AtTime"].asString(); + if(!timerNodeSchedulesSchedule["TargetReplicas"].isNull()) + scheduleObject.targetReplicas = std::stoi(timerNodeSchedulesSchedule["TargetReplicas"].asString()); data_.timer.schedules.push_back(scheduleObject); } auto metricNode = dataNode["Metric"]; - if(!metricNode["MinReplicas"].isNull()) - data_.metric.minReplicas = std::stoi(metricNode["MinReplicas"].asString()); if(!metricNode["MaxReplicas"].isNull()) data_.metric.maxReplicas = std::stoi(metricNode["MaxReplicas"].asString()); + if(!metricNode["MinReplicas"].isNull()) + data_.metric.minReplicas = std::stoi(metricNode["MinReplicas"].asString()); auto allMetricsNode = metricNode["Metrics"]["Metric"]; for (auto metricNodeMetricsMetric : allMetricsNode) { Data::Metric::Metric1 metric1Object; - if(!metricNodeMetricsMetric["MetricType"].isNull()) - metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString(); if(!metricNodeMetricsMetric["MetricTargetAverageUtilization"].isNull()) metric1Object.metricTargetAverageUtilization = std::stoi(metricNodeMetricsMetric["MetricTargetAverageUtilization"].asString()); + if(!metricNodeMetricsMetric["MetricType"].isNull()) + metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString(); data_.metric.metrics.push_back(metric1Object); } if(!value["TraceId"].isNull())