updated testing and namespace

Author: kai-ion

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

@@ -14,87 +14,96 @@
 #include <aws/core/utils/logging/LogMacros.h>
 
 using namespace Aws::Utils::Threading;
+using namespace Aws::Client;
 
 static const char RETRY_STRATEGY_TAG[] = "StandardRetryStrategy";
+static const int INITIAL_RETRY_TOKENS = 500;
+static const int RETRY_COST = 5;
+static const int TIMEOUT_RETRY_COST = 10;
 
 namespace Aws
 {
     namespace Client
     {
-        static const int INITIAL_RETRY_TOKENS = 500;
-        static const int RETRY_COST = 5;
-        static const int TIMEOUT_RETRY_COST = 10;
-
-        static bool IsNewRetriesEnabled()
-        {
-            return Aws::Utils::StringUtils::ToLower(Aws::Environment::GetEnv("AWS_NEW_RETRIES_2026").c_str()) == "true";
-        }
-
-        struct StandardRetryStrategy::RetryImpl
+        class StandardRetryStrategy::RetryImpl
         {
+        public:
             virtual ~RetryImpl() = default;
             virtual long CalculateDelay(const AWSError<CoreErrors>& error, long attemptedRetries) const = 0;
         };
+    }
+}
+
+namespace {
+    bool IsNewRetriesEnabled()
+    {
+        return Aws::Utils::StringUtils::ToLower(Aws::Environment::GetEnv("AWS_NEW_RETRIES_2026").c_str()) == "true";
+    }
 
-        namespace {
-        struct LegacyRetryImpl : StandardRetryStrategy::RetryImpl
+    class LegacyRetryImpl : public StandardRetryStrategy::RetryImpl
+    {
+    public:
+        long CalculateDelay(const AWSError<CoreErrors>& error, long attemptedRetries) const override
         {
-            long CalculateDelay(const AWSError<CoreErrors>& error, long attemptedRetries) const override
-            {
-                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);
-            }
-        };
+            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);
+        }
+    };
 
-        struct NewRetriesImpl : StandardRetryStrategy::RetryImpl
+    class NewRetriesImpl : public StandardRetryStrategy::RetryImpl
+    {
+    public:
+        long CalculateDelay(const AWSError<CoreErrors>& error, long attemptedRetries) const override
         {
-            long CalculateDelay(const AWSError<CoreErrors>& error, long attemptedRetries) const override
-            {
-                double x = error.ShouldThrottle() ? 1.0 : 0.05;
-                double exponentialPart = x * static_cast<double>(1L << (std::min)(attemptedRetries, 30L));
-                double cappedPart = (std::min)(exponentialPart, 20.0);
+            double x = error.ShouldThrottle() ? 1.0 : 0.05;
+            double exponentialPart = x * static_cast<double>(1L << (std::min)(attemptedRetries, 30L));
+            double cappedPart = (std::min)(exponentialPart, 20.0);
 
-                double b = static_cast<double>(Aws::Utils::GetRandomValue() % 10000) / 10000.0;
-                double t_i = b * cappedPart;
+            double b = static_cast<double>(Aws::Utils::GetRandomValue() % 10000) / 10000.0;
+            double t_i = b * cappedPart;
 
-                const auto& headers = error.GetResponseHeaders();
-                auto it = headers.find("x-amz-retry-after");
-                if (it != headers.end())
+            const auto& headers = error.GetResponseHeaders();
+            auto it = headers.find("x-amz-retry-after");
+            if (it != headers.end())
+            {
+                long long headerMs = Aws::Utils::StringUtils::ConvertToInt64(it->second.c_str());
+                if (headerMs < 0)
                 {
-                    long long headerMs = Aws::Utils::StringUtils::ConvertToInt64(it->second.c_str());
-                    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);
+                    AWS_LOGSTREAM_DEBUG(RETRY_STRATEGY_TAG, "Ignoring invalid x-amz-retry-after value: " << it->second);
                 }
-
-                return static_cast<long>(t_i * 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);
             }
-        };
-        } // anonymous namespace
 
-        static Aws::UniquePtr<StandardRetryStrategy::RetryImpl> CreateRetryImpl()
+            return static_cast<long>(t_i * 1000.0);
+        }
+    };
+
+    Aws::UniquePtr<StandardRetryStrategy::RetryImpl> CreateRetryImpl()
+    {
+        if (IsNewRetriesEnabled())
         {
-            if (IsNewRetriesEnabled())
-            {
-                return Aws::MakeUnique<NewRetriesImpl>("StandardRetryStrategy");
-            }
-            return Aws::MakeUnique<LegacyRetryImpl>("StandardRetryStrategy");
+            return Aws::MakeUnique<NewRetriesImpl>("StandardRetryStrategy");
         }
+        return Aws::MakeUnique<LegacyRetryImpl>("StandardRetryStrategy");
+    }
 
-        static std::shared_ptr<RetryQuotaContainer> CreateQuotaContainer()
+    std::shared_ptr<RetryQuotaContainer> CreateQuotaContainer()
+    {
+        if (IsNewRetriesEnabled())
         {
-            if (IsNewRetriesEnabled())
-            {
-                return Aws::MakeShared<ThrottleBasedRetryQuotaContainer>("StandardRetryStrategy");
-            }
-            return Aws::MakeShared<DefaultRetryQuotaContainer>("StandardRetryStrategy");
+            return Aws::MakeShared<ThrottleBasedRetryQuotaContainer>("StandardRetryStrategy");
         }
+        return Aws::MakeShared<DefaultRetryQuotaContainer>("StandardRetryStrategy");
+    }
+} // anonymous namespace
 
+namespace Aws
+{
+    namespace Client
+    {
         StandardRetryStrategy::StandardRetryStrategy(long maxAttempts)
             : m_retryQuotaContainer(CreateQuotaContainer()), m_maxAttempts(maxAttempts),
               m_impl(CreateRetryImpl()) {}