v1 add support for crt

Author: sbera87

generated/src/aws-cpp-sdk-s3-crt/source/S3CrtClient.cpp

@@ -1217,6 +1217,7 @@ void S3CrtClient::PutObjectAsync(const PutObjectRequest& request, const PutObjec
           CoreErrors::ENDPOINT_RESOLUTION_FAILURE, "ENDPOINT_RESOLUTION_FAILURE", endpointResolutionOutcome.GetError().GetMessage(), false)), handlerContext);
       return;
   }
+
   endpointResolutionOutcome.GetResult().AddPathSegments(request.GetKey());
 
   request.SetServiceSpecificParameters(
@@ -1226,6 +1227,22 @@ void S3CrtClient::PutObjectAsync(const PutObjectRequest& request, const PutObjec
           ServiceSpecificParameters serviceSpecificParameters{params};
           return Aws::MakeShared<ServiceSpecificParameters>(ALLOCATION_TAG, serviceSpecificParameters);
       }());
+    
+    //changes
+    EndpointUpdateCallback endpointCallback = [&](Aws::Endpoint::AWSEndpoint& endpoint){
+      endpoint.AddPathSegments(request.GetKey());
+    };
+  
+    auto endpointResolutionOutcome = ResolveEndpoint(
+      &request,
+      request.GetServiceRequestName(),
+      Aws::Http::HttpMethod method,
+      std::move(endpointCallback))
+    if (!endpointResolutionOutcome.IsSuccess()) {
+        handler(this, request, PutObjectOutcome(Aws::Client::AWSError<CoreErrors>(
+            CoreErrors::ENDPOINT_RESOLUTION_FAILURE, "ENDPOINT_RESOLUTION_FAILURE", endpointResolutionOutcome.GetError().GetMessage(), false)), handlerContext);
+        return;
+    }
 
   // make aws_s3_meta_request with callbacks
   CrtRequestCallbackUserData *userData = Aws::New<CrtRequestCallbackUserData>(ALLOCATION_TAG);

src/aws-cpp-sdk-core/include/smithy/client/AwsSmithyClient.h

@@ -212,6 +212,49 @@ namespace client
             return AwsClientRequestSigning<AuthSchemesVariantT>::AdjustClockSkew(outcome, authSchemeOption, m_authSchemes);
         }
 
+        ResolveEndpointOutcome ResolveEndpoint(
+            Aws::AmazonWebServiceRequest const * const request,
+            const char* requestName,
+            Aws::Http::HttpMethod method,
+            EndpointUpdateCallback&& endpointCallback) const
+        {
+            std::shared_ptr<Aws::Utils::Threading::Executor> pExecutor = Aws::MakeShared<Aws::Utils::Threading::SameThreadExecutor>(AWS_SMITHY_CLIENT_LOG);
+            assert(pExecutor);
+        
+            ResolveEndpointOutcome outcome = ClientError(CoreErrors::INTERNAL_FAILURE, "", "Response handler was not called", false);
+            ResponseHandlerFunc responseHandler = [&outcome](HttpResponseOutcome&& asyncOutcome)
+            {
+                outcome = std::move(asyncOutcome);
+            }
+            std::shared_ptr<AwsSmithyClientAsyncRequestContext> pRequestCtx =
+            Aws::MakeShared<AwsSmithyClientAsyncRequestContext>(AWS_SMITHY_CLIENT_LOG);
+            if (!pRequestCtx)
+            {
+                AWS_LOGSTREAM_ERROR(AWS_SMITHY_CLIENT_LOG, "Failed to allocate an AwsSmithyClientAsyncRequestContext under a shared ptr");
+                auto outcome = HttpResponseOutcome(ClientError(CoreErrors::MEMORY_ALLOCATION, "", "Failed to allocate async request context", false/*retryable*/));
+                pExecutor->Submit([outcome, responseHandler]() mutable
+                {
+                    responseHandler(std::move(outcome));
+                } );
+                return;
+            }
+        
+            pExecutor->Submit([&]()
+            {            
+                this->ResolveAuthEndpoint(
+                    pRequestCtx,
+                    request,
+                    requestName,
+                    method,
+                    std::move(responseHandler),
+                    std::move(endpointCallback),
+                    pExecutor
+                )
+            });
+            pExecutor->WaitUntilStopped();
+            return outcome;
+        }
+
         IdentityOutcome ResolveIdentity(const AwsSmithyClientAsyncRequestContext& ctx) const override {
           return AwsClientRequestSigning<AuthSchemesVariantT>::ResolveIdentity(ctx, m_authSchemes);
         }

src/aws-cpp-sdk-core/include/smithy/client/AwsSmithyClientBase.h

@@ -159,6 +159,16 @@ namespace client
             return m_errorMarshaller;
         }
 
+        bool ResolveAuthEndpoint(
+            std::shared_ptr<AwsSmithyClientAsyncRequestContext>& pRequestCtx,
+            Aws::AmazonWebServiceRequest const * const request,
+            const char* requestName,
+            Aws::Http::HttpMethod method,
+            ResponseHandlerFunc&& responseHandler,
+            EndpointUpdateCallback&& endpointCallback,
+            std::shared_ptr<Aws::Utils::Threading::Executor>& pExecutor
+        ) const;
+
         /**
          * Initialize client configuration with their factory method, unless the user has explicitly set the
          * configuration, and it is to be shallow copied between different clients, in which case, delete the

src/aws-cpp-sdk-core/source/smithy/client/AwsSmithyClientBase.cpp

@@ -177,6 +177,56 @@ AwsSmithyClientBase::BuildHttpRequest(const std::shared_ptr<AwsSmithyClientAsync
     return httpRequest;
 }
 
+bool AwsSmithyClientBase::ResolveAuthEndpoint(
+    std::shared_ptr<AwsSmithyClientAsyncRequestContext>& pRequestCtx,
+    Aws::AmazonWebServiceRequest const * const request,
+    const char* requestName,
+    Aws::Http::HttpMethod method,
+    ResponseHandlerFunc&& responseHandler,
+    EndpointUpdateCallback&& endpointCallback,
+    std::shared_ptr<Aws::Utils::Threading::Executor>& pExecutor
+) const
+{
+    pRequestCtx->m_pRequest = request;
+    if (requestName)
+      pRequestCtx->m_requestName = requestName;
+    else if (pRequestCtx->m_pRequest)
+      pRequestCtx->m_requestName = pRequestCtx->m_pRequest->GetServiceRequestName();
+    pRequestCtx->m_method = method;
+    pRequestCtx->m_retryCount = 0;
+    pRequestCtx->m_invocationId = Aws::Utils::UUID::PseudoRandomUUID();
+    auto authSchemeOptionOutcome = this->SelectAuthSchemeOption(*pRequestCtx);
+    if (!authSchemeOptionOutcome.IsSuccess())
+    {
+        pExecutor->Submit([authSchemeOptionOutcome, responseHandler]() mutable
+          {
+              responseHandler(std::move(authSchemeOptionOutcome));
+          } );
+        return false;
+    }
+    pRequestCtx->m_authSchemeOption = std::move(authSchemeOptionOutcome.GetResultWithOwnership());
+    assert(pRequestCtx->m_authSchemeOption.schemeId);
+    Aws::Endpoint::EndpointParameters epParams = request ? request->GetEndpointContextParams() : Aws::Endpoint::EndpointParameters();
+    const auto authSchemeEpParams = pRequestCtx->m_authSchemeOption.endpointParameters();
+    epParams.insert(epParams.end(), authSchemeEpParams.begin(), authSchemeEpParams.end());
+    auto epResolutionOutcome = this->ResolveEndpoint(std::move(epParams), std::move(endpointCallback));
+    if (!epResolutionOutcome.IsSuccess())
+    {
+        auto epOutcome = ResolveEndpointOutcome(Aws::Client::AWSError<Aws::Client::CoreErrors>{
+            Aws::Client::CoreErrors::ENDPOINT_RESOLUTION_FAILURE,
+            epResolutionOutcome.GetError().GetExceptionName(),
+            epResolutionOutcome.GetError().GetMessage(),
+            false});
+
+        pExecutor->Submit([epOutcome, responseHandler]() mutable
+          {
+              responseHandler(std::move(epOutcome));
+          } );
+        return false;
+    }
+    return true;
+}
+
 void AwsSmithyClientBase::MakeRequestAsync(Aws::AmazonWebServiceRequest const* const request,
                                            const char* requestName,
                                            Aws::Http::HttpMethod method,