Smithy Identity auth refactor for Rest XML S3 client

generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h

@@ -4,14 +4,22 @@
  */
 
 #pragma once
+
 #include <aws/s3/S3_EXPORTS.h>
 #include <aws/core/client/ClientConfiguration.h>
-#include <aws/core/client/AWSClient.h>
 #include <aws/core/client/AWSClientAsyncCRTP.h>
-#include <aws/core/auth/AWSAuthSigner.h>
-#include <aws/core/utils/xml/XmlSerializer.h>
-#include <aws/core/utils/DNS.h>
 #include <aws/s3/S3ServiceClientModel.h>
+#include <smithy/client/AwsSmithyClient.h>
+#include <smithy/identity/auth/built-in/SigV4MultiAuthResolver.h>
+#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
+#include <smithy/identity/auth/built-in/SigV4aAuthScheme.h>
+#include <smithy/identity/auth/built-in/S3ExpressSigV4AuthScheme.h>
+#include <smithy/client/serializer/XmlOutcomeSerializer.h>
+#include <aws/core/utils/DNS.h>
+
+#include <aws/s3/S3ErrorMarshaller.h>
+
+
 
 // TODO: temporary fix for naming conflicts on Windows.
 #ifdef _WIN32
@@ -32,19 +40,28 @@ namespace Aws
         static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY[] = "x-amz-server-side-encryption-customer-key";
         static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5[] = "x-amz-server-side-encryption-customer-key-MD5";
     } // SS3Headers
+    AWS_S3_API extern const char SERVICE_NAME[];
 
     //max expiration for presigned urls in s3 is 7 days.
     static const unsigned MAX_EXPIRATION_SECONDS = 7 * 24 * 60 * 60;
 
     /**
      * <p/>
      */
-    class AWS_S3_API S3Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<S3Client>
+    class AWS_S3_API S3Client : public smithy::client::AwsSmithyClientT<Aws::S3::SERVICE_NAME,
+      Aws::S3::S3ClientConfiguration,
+      smithy::SigV4MultiAuthSchemeResolver<>,
+      Aws::Crt::Variant<smithy::SigV4AuthScheme,smithy::S3ExpressSigV4AuthScheme,smithy::SigV4aAuthScheme>,
+      S3EndpointProviderBase,
+      smithy::client::XmlOutcomeSerializer,
+      smithy::client::XmlOutcome,
+      Aws::Client::S3ErrorMarshaller>,
+    Aws::Client::ClientWithAsyncTemplateMethods<S3Client>
     {
     public:
-        typedef Aws::Client::AWSXMLClient BASECLASS;
         static const char* GetServiceName();
         static const char* GetAllocationTag();
+        inline const char* GetServiceClientName() const override { return "S3"; }
 
       typedef S3ClientConfiguration ClientConfigurationType;
       typedef S3EndpointProvider EndpointProviderType;
@@ -6973,8 +6990,7 @@ namespace Aws
     private:
         friend class Aws::Client::ClientWithAsyncTemplateMethods<S3Client>;
         void init(const S3ClientConfiguration& clientConfiguration);
-        S3ClientConfiguration m_clientConfiguration;
-        std::shared_ptr<S3EndpointProviderBase> m_endpointProvider;
+
     };
 
   } // namespace S3

generated/src/aws-cpp-sdk-s3/include/aws/s3/S3ClientConfiguration.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include <aws/s3/S3_EXPORTS.h>
-#include <aws/s3/S3ExpressIdentityProvider.h>
 #include <aws/core/client/GenericClientConfiguration.h>
 #include <aws/core/auth/signer/AWSAuthV4Signer.h>
 
@@ -58,10 +57,6 @@ namespace Aws
             bool useArnRegion = false;
             Client::AWSAuthV4Signer::PayloadSigningPolicy payloadSigningPolicy = Client::AWSAuthV4Signer::PayloadSigningPolicy::RequestDependent;
             bool disableS3ExpressAuth = false;
-            using IdentityProviderSupplier = std::function<std::shared_ptr<S3ExpressIdentityProvider> (const S3Client &)>;
-            IdentityProviderSupplier identityProviderSupplier = [](const S3Client &client) -> std::shared_ptr<S3ExpressIdentityProvider> {
-                return Aws::MakeShared<DefaultS3ExpressIdentityProvider>("S3ClientConfiguration", client);
-            };
         private:
             void LoadS3SpecificConfig(const Aws::String& profileName);
         };

generated/src/aws-cpp-sdk-s3/include/aws/s3/S3ExpressIdentityResolver.h

@@ -0,0 +1,96 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/utils/memory/stl/AWSSet.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/ConcurrentCache.h>
+#include <smithy/identity/resolver/AwsIdentityResolverBase.h>
+#include <smithy/identity/identity/AwsCredentialIdentity.h>
+#include <thread>
+#include <condition_variable>
+
+namespace Aws {
+    namespace Http {
+        struct ServiceSpecificParameters;
+    }
+
+    namespace S3 {
+        class S3Client;
+        class S3ExpressIdentityResolver : public smithy::IdentityResolverBase<smithy::AwsCredentialIdentityBase> {
+         public:
+          explicit S3ExpressIdentityResolver(const S3Client& s3Client);
+          explicit S3ExpressIdentityResolver(const S3Client& s3Client, const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>  credentialProvider);
+          ResolveIdentityFutureOutcome getIdentity(
+              const IdentityProperties& identityProperties,
+              const AdditionalParameters& additionalParameters) override;
+          virtual smithy::AwsCredentialIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) = 0;
+          smithy::AwsCredentialIdentity GetCredentialsFromBucket(const Aws::String& bucketName) const;
+
+         private:
+          const Aws::S3::S3Client& m_s3Client;
+          mutable std::mutex m_bucketNameMapMutex;
+          Aws::Map<Aws::String, std::shared_ptr<std::mutex>> m_bucketNameMutex;
+
+         protected:
+          std::shared_ptr<std::mutex> GetMutexForBucketName(const Aws::String& bucketName);
+          mutable std::shared_ptr<Aws::Auth::AWSCredentialsProvider> m_credsProvider;
+        };
+
+        class DefaultS3ExpressIdentityResolver : public S3ExpressIdentityResolver {
+         public:
+          explicit DefaultS3ExpressIdentityResolver(const S3Client& s3Client);
+          explicit DefaultS3ExpressIdentityResolver(
+              const S3Client& s3Client,
+              std::shared_ptr<Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> credentialsCache);
+          explicit DefaultS3ExpressIdentityResolver(const S3Client& s3Client, const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>  credentialProvider);
+          DefaultS3ExpressIdentityResolver(const DefaultS3ExpressIdentityResolver& other) = delete;
+          DefaultS3ExpressIdentityResolver(DefaultS3ExpressIdentityResolver&& other) noexcept = delete;
+          DefaultS3ExpressIdentityResolver& operator=(const DefaultS3ExpressIdentityResolver& other) = delete;
+          DefaultS3ExpressIdentityResolver& operator=(DefaultS3ExpressIdentityResolver&& other) noexcept = delete;
+          virtual ~DefaultS3ExpressIdentityResolver() override = default;
+          smithy::AwsCredentialIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;
+
+         private:
+          mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> m_credentialsCache;
+        };
+
+        class DefaultAsyncS3ExpressIdentityResolver : public S3ExpressIdentityResolver {
+         public:
+          explicit DefaultAsyncS3ExpressIdentityResolver(
+              const S3Client& s3Client,
+              std::chrono::minutes refreshPeriod = std::chrono::minutes(1));
+
+          explicit DefaultAsyncS3ExpressIdentityResolver(
+              const S3Client& s3Client,
+              std::shared_ptr<Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> credentialsCache,
+              std::chrono::minutes refreshPeriod = std::chrono::minutes(1));
+
+          DefaultAsyncS3ExpressIdentityResolver(const DefaultAsyncS3ExpressIdentityResolver& other) = delete;
+          DefaultAsyncS3ExpressIdentityResolver(DefaultAsyncS3ExpressIdentityResolver&& other) noexcept = delete;
+          DefaultAsyncS3ExpressIdentityResolver& operator=(
+              const DefaultAsyncS3ExpressIdentityResolver& other) = delete;
+          DefaultAsyncS3ExpressIdentityResolver& operator=(DefaultAsyncS3ExpressIdentityResolver&& other) noexcept = delete;
+          virtual ~DefaultAsyncS3ExpressIdentityResolver() override;
+          smithy::AwsCredentialIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;
+
+
+         private:
+          void refreshIdentities(std::chrono::minutes refreshPeriod);
+          void threadSafeKeyInsert(const Aws::String& key);
+          bool threadSafeKeyHas(const Aws::String& key);
+          void threadSafeKeyEmpty();
+
+          mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> m_credentialsCache;
+          Aws::Set<Aws::String> m_keysUsed;
+          mutable std::mutex m_keysUsedMutex;
+          mutable bool m_shouldStopBackgroundRefresh;
+          Aws::UniquePtr<std::thread> m_backgroundRefreshThread;
+          mutable std::mutex m_shutDownMutex;
+          mutable std::condition_variable m_shutdownCondition;
+        };
+    }
+}