fixed static int to structs

Author: kai-ion

src/aws-cpp-sdk-core/include/aws/core/internal/RetryStrategyImpl.h

@@ -15,15 +15,18 @@ namespace Aws
 {
     namespace Client
     {
-        static const int THROTTLE_BASED_RETRY_COST = 14;
-        static const int THROTTLE_BASED_THROTTLING_COST = 5;
-        static const int THROTTLE_BASED_INITIAL_TOKENS = 500;
+        struct QuotaConfig
+        {
+            int retryCost = 14;
+            int throttlingCost = 5;
+            int initialTokens = 500;
+        };
 
         class AWS_CORE_LOCAL ThrottleBasedRetryQuotaContainer : public RetryQuotaContainer
         {
         public:
-            ThrottleBasedRetryQuotaContainer(int retryCost = THROTTLE_BASED_RETRY_COST, int throttlingRetryCost = THROTTLE_BASED_THROTTLING_COST)
-                : m_retryQuota(THROTTLE_BASED_INITIAL_TOKENS), m_retryCost(retryCost), m_throttlingRetryCost(throttlingRetryCost) {}
+            ThrottleBasedRetryQuotaContainer(const QuotaConfig& config = QuotaConfig{})
+                : m_config(config), m_retryQuota(config.initialTokens) {}
 
             virtual ~ThrottleBasedRetryQuotaContainer() = default;
 
@@ -43,29 +46,28 @@ namespace Aws
 
             bool AcquireRetryQuota(const AWSError<CoreErrors>& error) override
             {
-                int capacityAmount = error.ShouldThrottle() ? m_throttlingRetryCost : m_retryCost;
+                int capacityAmount = error.ShouldThrottle() ? m_config.throttlingCost : m_config.retryCost;
                 return AcquireRetryQuota(capacityAmount);
             }
 
             void ReleaseRetryQuota(int capacityAmount) override
             {
                 Aws::Utils::Threading::WriterLockGuard guard(m_retryQuotaLock);
-                m_retryQuota = (std::min)(m_retryQuota + capacityAmount, THROTTLE_BASED_INITIAL_TOKENS);
+                m_retryQuota = (std::min)(m_retryQuota + capacityAmount, m_config.initialTokens);
             }
 
             void ReleaseRetryQuota(const AWSError<CoreErrors>& error) override
             {
-                int capacityAmount = error.ShouldThrottle() ? m_throttlingRetryCost : m_retryCost;
+                int capacityAmount = error.ShouldThrottle() ? m_config.throttlingCost : m_config.retryCost;
                 ReleaseRetryQuota(capacityAmount);
             }
 
             int GetRetryQuota() const override { return m_retryQuota; }
 
         private:
+            QuotaConfig m_config;
             mutable Aws::Utils::Threading::ReaderWriterLock m_retryQuotaLock;
             int m_retryQuota;
-            int m_retryCost;
-            int m_throttlingRetryCost;
         };
     } // namespace Client
 } // namespace Aws

src/aws-cpp-sdk-core/source/client/RetryStrategy.cpp

@@ -16,8 +16,6 @@
 using namespace Aws::Utils::Threading;
 using namespace Aws::Client;
 
-static const char RETRY_STRATEGY_TAG[] = "StandardRetryStrategy";
-
 namespace Aws
 {
     namespace Client
@@ -32,6 +30,8 @@ namespace Aws
 }
 
 namespace {
+    const char RETRY_STRATEGY_TAG[] = "StandardRetryStrategy";
+
     bool IsNewRetriesEnabled()
     {
         return Aws::Utils::StringUtils::ToLower(Aws::Environment::GetEnv("AWS_NEW_RETRIES_2026").c_str()) == "true";
@@ -44,7 +44,7 @@ namespace {
         {
             AWS_UNREFERENCED_PARAM(error);
             // Maximum left shift factor is capped by ceil(log2(max_delay)), to avoid wrap-around and overflow into negative values:
-            return std::min(static_cast<int>(Aws::Utils::GetRandomValue() % 1000) * (1 << std::min(attemptedRetries, 15L)), 20000);
+            return (std::min)(static_cast<int>(Aws::Utils::GetRandomValue() % 1000) * (1 << (std::min)(attemptedRetries, 15L)), 20000);
         }
     };
 
@@ -65,13 +65,13 @@ namespace {
             if (it != headers.end())
             {
                 long long headerMs = Aws::Utils::StringUtils::ConvertToInt64(it->second.c_str());
-                if (headerMs < 0)
+                if (headerMs >= 0)
                 {
-                    AWS_LOGSTREAM_DEBUG(RETRY_STRATEGY_TAG, "Ignoring invalid x-amz-retry-after value: " << it->second);
+                    double headerSec = static_cast<double>(headerMs) / 1000.0;
+                    double clamped = (std::max)(t_i, (std::min)(headerSec, 5.0 + t_i));
+                    return static_cast<long>(clamped * 1000.0);
                 }
-                double headerSec = static_cast<double>(headerMs) / 1000.0;
-                double clamped = (std::max)(t_i, (std::min)(headerSec, 5.0 + t_i));
-                return static_cast<long>(clamped * 1000.0);
+                AWS_LOGSTREAM_DEBUG(RETRY_STRATEGY_TAG, "Ignoring invalid x-amz-retry-after value: " << it->second);
             }
 
             return static_cast<long>(t_i * 1000.0);

tests/aws-cpp-sdk-core-tests/aws/client/RetryStrategyTest.cpp

@@ -290,8 +290,4 @@ TEST_F(NewRetriesStrategyTest, InvalidRetryAfterFallsBack)
     long delay = retryStrategy.CalculateDelayBeforeNextRetry(error, 0);
     ASSERT_GE(delay, 0);
     ASSERT_LE(delay, 50);
-}
-
-// SEP Test Cases 2, 4, 7 are covered by TestStandardRetryStrategy above (same behavior with/without gate).
-// TODO: SEP Test Case 11 (DynamoDB 25ms base) deferred to next PR.
-// TODO: SEP Test Cases 12-16 (long-polling) require pipeline integration tests.
+}