upload/download changes

Author: narahavi

crt/aws-crt-cpp

@@ -12,8 +12,8 @@ namespace Transfer {
 
 /**
  * Callback interface for zero-copy downloads. The transfer manager delivers each part of the
- * object to OnDataReceived as it arrives, in object order. Keep a copy of the buffer to retain
- * the bytes past this call.
+ * object to OnDataReceived as it arrives, in object order. The buffer is move-only; move it out
+ * (e.g. auto held = std::move(buffer)) to retain the bytes past this call.
  */
 class AWS_S3_TRANSFER_API DownloadDataReceiver {
  public:

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/DownloadDataReceiver.h

@@ -24,8 +24,8 @@ class AWS_S3_TRANSFER_API S3DownloadBuffer final {
   explicit S3DownloadBuffer(std::shared_ptr<Aws::Crt::S3::S3BufferTicket> ticket,
                             Aws::Crt::ByteCursor bytes, uint64_t rangeStart) noexcept;
 
-  S3DownloadBuffer(const S3DownloadBuffer&) = default;
-  S3DownloadBuffer& operator=(const S3DownloadBuffer&) = default;
+  S3DownloadBuffer(const S3DownloadBuffer&) = delete;
+  S3DownloadBuffer& operator=(const S3DownloadBuffer&) = delete;
   S3DownloadBuffer(S3DownloadBuffer&& other) noexcept;
   S3DownloadBuffer& operator=(S3DownloadBuffer&& other) noexcept;
   ~S3DownloadBuffer() = default;

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/S3DownloadBuffer.h

@@ -10,8 +10,9 @@
 #include <aws/s3-transfer/UploadHandle.h>
 #include <aws/s3-transfer/DownloadHandle.h>
 #include <aws/core/auth/AWSCredentialsProvider.h>
-#include <aws/core/utils/memory/AWSMemory.h>
+#include <aws/core/client/AWSError.h>
 #include <aws/s3/S3EndpointProvider.h>
+#include <aws/s3/S3Errors.h>
 #include <memory>
 
 namespace Aws {
@@ -22,7 +23,10 @@ class S3TransferManagerImpl;
 
 /**
  * Customers construct an instance directly. The manager owns the underlying CRT client; it is
- * neither copyable nor movable.
+ * neither copyable nor movable. If construction cannot produce a usable manager (e.g. the CRT
+ * S3 client fails to build), the instance enters an error state: IsInitialized() returns false
+ * and Upload()/Download() fail immediately via the returned handle with the specific init
+ * error. Customers can check IsInitialized() up-front, or rely on the per-call failure path.
  */
 class AWS_S3_TRANSFER_API S3TransferManager final {
  public:
@@ -31,20 +35,23 @@ class AWS_S3_TRANSFER_API S3TransferManager final {
    * config. If config is not specified, it will be initialized to default values.
    */
   S3TransferManager(const S3TransferManagerConfiguration& config = S3TransferManagerConfiguration(),
-                    std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider = nullptr);
+                    std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider =
+                        Aws::MakeShared<Aws::S3::Endpoint::S3EndpointProvider>("S3TransferManager"));
 
   /**
    * Initializes the transfer manager with the supplied static credentials and an optional config.
    */
   S3TransferManager(const Aws::Auth::AWSCredentials& credentials,
-                    std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider = nullptr,
+                    std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider =
+                        Aws::MakeShared<Aws::S3::Endpoint::S3EndpointProvider>("S3TransferManager"),
                     const S3TransferManagerConfiguration& config = S3TransferManagerConfiguration());
 
   /**
    * Initializes the transfer manager with the supplied credentials provider and an optional config.
    */
   S3TransferManager(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
-                    std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider = nullptr,
+                    std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider =
+                        Aws::MakeShared<Aws::S3::Endpoint::S3EndpointProvider>("S3TransferManager"),
                     const S3TransferManagerConfiguration& config = S3TransferManagerConfiguration());
 
   ~S3TransferManager();
@@ -54,6 +61,18 @@ class AWS_S3_TRANSFER_API S3TransferManager final {
   S3TransferManager(S3TransferManager&&) noexcept = delete;
   S3TransferManager& operator=(S3TransferManager&&) noexcept = delete;
 
+  /**
+   * True if construction succeeded. If false, Upload()/Download() will fail immediately via
+   * the returned handle with the error reported by GetInitializationError().
+   */
+  bool IsInitialized() const;
+
+  /**
+   * The specific error captured during construction. Only meaningful when IsInitialized() is
+   * false; on a successfully-initialized manager the returned error is default-constructed.
+   */
+  const Aws::Client::AWSError<Aws::S3::S3Errors>& GetInitializationError() const;
+
   /**
    * Begin uploading the object described by request. Returns immediately with a handle that can be
    * used to wait for completion or to cancel the in-flight transfer.
@@ -73,6 +92,3 @@ class AWS_S3_TRANSFER_API S3TransferManager final {
 }  // namespace Transfer
 }  // namespace S3
 }  // namespace Aws
-
-
-

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/S3TransferManager.h

@@ -5,11 +5,13 @@
 
 #pragma once
 
-#include <aws/core/client/GenericClientConfiguration.h>
 #include <aws/s3-transfer/S3Transfer_EXPORTS.h>
+#include <aws/s3/S3ClientConfiguration.h>
 #include <aws/crt/Optional.h>
 #include <aws/crt/io/TlsOptions.h>
+#include <aws/crt/s3/S3.h>
 #include <cstdint>
+#include <memory>
 
 namespace Aws {
 namespace S3 {
@@ -18,8 +20,8 @@ namespace Transfer {
 constexpr uint64_t DEFAULT_PART_SIZE_BYTES = 8ULL * 1024 * 1024;
 constexpr uint64_t DEFAULT_MULTIPART_UPLOAD_THRESHOLD_BYTES = 16ULL * 1024 * 1024;
 
-struct AWS_S3_TRANSFER_API S3TransferManagerConfiguration final : public Aws::Client::GenericClientConfiguration {
-  using BaseClientConfigClass = Aws::Client::GenericClientConfiguration;
+struct AWS_S3_TRANSFER_API S3TransferManagerConfiguration final : public Aws::S3::S3ClientConfiguration {
+  using BaseClientConfigClass = Aws::S3::S3ClientConfiguration;
 
   explicit S3TransferManagerConfiguration(const Aws::Client::ClientConfigurationInitValues& configuration = {});
   explicit S3TransferManagerConfiguration(const char* profileName, bool shouldDisableIMDS = false);
@@ -33,6 +35,8 @@ struct AWS_S3_TRANSFER_API S3TransferManagerConfiguration final : public Aws::Cl
   double throughputTargetGbps = 0.0;
   Aws::Crt::Optional<Aws::Crt::Io::TlsConnectionOptions> tlsConnectionOptions;
 
+  std::shared_ptr<Aws::Crt::S3::S3Client> crtClient;
+
  private:
   void LoadS3TransferManagerSpecificConfig(const Aws::String& profileName);
 };

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/S3TransferManagerConfiguration.h

@@ -8,12 +8,17 @@
 #include <aws/s3-transfer/S3Transfer_EXPORTS.h>
 #include <aws/s3-transfer/S3TransferManagerConfiguration.h>
 #include <aws/core/auth/AWSCredentialsProvider.h>
+#include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/UserAgent.h>
 #include <aws/core/utils/memory/AWSMemory.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
 #include <aws/s3/S3EndpointProvider.h>
+#include <aws/s3/S3Errors.h>
 #include <aws/crt/s3/S3.h>
 #include <aws/crt/auth/Credentials.h>
 #include <aws/core/utils/threading/Executor.h>
+#include <atomic>
 #include <cstdint>
 #include <memory>
 
@@ -27,11 +32,12 @@ constexpr size_t DEFAULT_EXECUTOR_POOL_SIZE = 8;
 class AWS_CORE_LOCAL S3TransferManagerImpl final {
  public:
   // Sole real constructor; the public overloads adapt their credentials shape into the
-  // AWSCredentialsProvider taken here. A null endpointProvider means "use the default
-  // S3EndpointProvider", matching generated-client behavior.
-  S3TransferManagerImpl(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
-                        const std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase>& endpointProvider,
-                        const S3TransferManagerConfiguration& config);
+  // AWSCredentialsProvider taken here.
+  S3TransferManagerImpl(const S3TransferManagerConfiguration& config,
+                        const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider =
+                            Aws::MakeShared<Aws::Auth::DefaultAWSCredentialsProviderChain>("S3TransferManagerImpl"),
+                        const std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase>& endpointProvider =
+                            Aws::MakeShared<Aws::S3::Endpoint::S3EndpointProvider>("S3TransferManagerImpl"));
   ~S3TransferManagerImpl();
 
   S3TransferManagerImpl(const S3TransferManagerImpl&) = delete;
@@ -41,19 +47,29 @@ class AWS_CORE_LOCAL S3TransferManagerImpl final {
 
   Aws::Crt::S3::S3Client& GetCrtClient() const { return *m_crtClient; }
   Aws::S3::Endpoint::S3EndpointProviderBase& GetEndpointProvider() const { return *m_endpointProvider; }
-  const Aws::String& GetRegion() const { return m_region; }
+  const S3TransferManagerConfiguration& GetConfig() const { return m_config; }
   const std::shared_ptr<Aws::Crt::Auth::ICredentialsProvider>& GetCredentialsProvider() const {
     return m_credentialsProvider;
   }
-  bool IsValid() const { return m_crtClient != nullptr && static_cast<bool>(*m_crtClient); }
+  bool IsCustomerSuppliedCrtClient() const { return m_customerSuppliedCrtClient; }
+  // Ctor sets to false on any construction failure and stashes the specific reason in
+  // m_initError. S3TransferManager::Create() inspects this to gate object handoff — a customer
+  // never receives a borked S3TransferManager.
+  bool IsInitialized() const { return m_isInitialized.load(); }
+  const Aws::Client::AWSError<Aws::S3::S3Errors>& GetInitializationError() const { return m_initError; }
   Aws::Utils::Threading::Executor& GetExecutor() const { return *m_executor; }
+  const Aws::String& GetUserAgentString() const { return m_userAgent; }
 
  private:
-  Aws::String m_region;
+  S3TransferManagerConfiguration m_config;
   std::shared_ptr<Aws::Crt::Auth::ICredentialsProvider> m_credentialsProvider;
   std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> m_endpointProvider;
-  Aws::UniquePtr<Aws::Crt::S3::S3Client> m_crtClient;
+  std::shared_ptr<Aws::Crt::S3::S3Client> m_crtClient;
   std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
+  std::atomic<bool> m_isInitialized{true};
+  Aws::Client::AWSError<Aws::S3::S3Errors> m_initError;
+  bool m_customerSuppliedCrtClient = false;
+  Aws::String m_userAgent;
 };
 
 }  // namespace Transfer

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/internal/S3TransferManagerImpl.h

@@ -61,7 +61,7 @@ struct AWS_CORE_LOCAL TransferStateBase {
   }
 
  private:
-  mutable std::mutex m_metaRequestLock;
+  std::mutex m_metaRequestLock;
   std::shared_ptr<Aws::Crt::S3::S3MetaRequest> m_metaRequest;
 };
 

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/internal/TransferState.h

@@ -19,23 +19,29 @@ S3TransferManager::~S3TransferManager() = default;
 S3TransferManager::S3TransferManager(const S3TransferManagerConfiguration& config,
                                      std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider)
     : m_impl(Aws::MakeUnique<S3TransferManagerImpl>(
-          S3_TRANSFER_MANAGER_ALLOCATION_TAG,
+          S3_TRANSFER_MANAGER_ALLOCATION_TAG, config,
           Aws::MakeShared<Aws::Auth::DefaultAWSCredentialsProviderChain>(S3_TRANSFER_MANAGER_ALLOCATION_TAG),
-          endpointProvider, config)) {}
+          endpointProvider)) {}
 
 S3TransferManager::S3TransferManager(const Aws::Auth::AWSCredentials& credentials,
                                      std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider,
                                      const S3TransferManagerConfiguration& config)
     : m_impl(Aws::MakeUnique<S3TransferManagerImpl>(
-          S3_TRANSFER_MANAGER_ALLOCATION_TAG,
+          S3_TRANSFER_MANAGER_ALLOCATION_TAG, config,
           Aws::MakeShared<Aws::Auth::SimpleAWSCredentialsProvider>(S3_TRANSFER_MANAGER_ALLOCATION_TAG, credentials),
-          endpointProvider, config)) {}
+          endpointProvider)) {}
 
 S3TransferManager::S3TransferManager(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                      std::shared_ptr<Aws::S3::Endpoint::S3EndpointProviderBase> endpointProvider,
                                      const S3TransferManagerConfiguration& config)
-    : m_impl(Aws::MakeUnique<S3TransferManagerImpl>(S3_TRANSFER_MANAGER_ALLOCATION_TAG, credentialsProvider,
-                                                    endpointProvider, config)) {}
+    : m_impl(Aws::MakeUnique<S3TransferManagerImpl>(
+          S3_TRANSFER_MANAGER_ALLOCATION_TAG, config, credentialsProvider, endpointProvider)) {}
+
+bool S3TransferManager::IsInitialized() const { return m_impl->IsInitialized(); }
+
+const Aws::Client::AWSError<Aws::S3::S3Errors>& S3TransferManager::GetInitializationError() const {
+  return m_impl->GetInitializationError();
+}
 
 UploadHandle S3TransferManager::Upload(const UploadRequest& request) {
   return Internal::CrtOperations::DispatchUpload(*m_impl, request);