Skip to content

Headobject crt impl #3864

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
pulimsr wants to merge 4 commits into
base: main
Choose a base branch
from
Open

Headobject crt impl #3864

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
37e702d
move Head Object in crt client to aws-c-s3 implementation
sbiscigl Jul 1, 2026
8c26da6
Merge branch 'headobject-crt-impl' of github.com:aws/aws-sdk-cpp into…
pulimsr Jul 7, 2026
757a853
Merge branch 'main' of github.com:aws/aws-sdk-cpp into headobject-crt…
pulimsr Jul 13, 2026
42d2568
Regenerating S3CrtClient and updating Velocity templates for HeadObje…
pulimsr Jul 13, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 3 additions & 13 deletions generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtClient.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4675,23 +4675,12 @@ class AWS_S3CRT_API S3CrtClient : public Aws::Client::AWSXMLClient,
*/
virtual Model::HeadObjectOutcome HeadObject(const Model::HeadObjectRequest& request) const;

/**
* A Callable wrapper for HeadObject that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template <typename HeadObjectRequestT = Model::HeadObjectRequest>
Model::HeadObjectOutcomeCallable HeadObjectCallable(const HeadObjectRequestT& request) const {
return SubmitCallable(&S3CrtClient::HeadObject, request);
}

/**
* An Async wrapper for HeadObject that queues the request into a thread executor and triggers associated callback when operation has
* finished.
*/
template <typename HeadObjectRequestT = Model::HeadObjectRequest>
void HeadObjectAsync(const HeadObjectRequestT& request, const HeadObjectResponseReceivedHandler& handler,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
return SubmitAsync(&S3CrtClient::HeadObject, request, handler, context);
}
virtual void HeadObjectAsync(const Model::HeadObjectRequest& request, const HeadObjectResponseReceivedHandler& handler,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

/**
* <p>This operation is not supported for directory buckets.</p>
Expand Down Expand Up @@ -8720,6 +8709,7 @@ class AWS_S3CRT_API S3CrtClient : public Aws::Client::AWSXMLClient,
GetObjectResponseReceivedHandler getResponseHandler;
PutObjectResponseReceivedHandler putResponseHandler;
CopyObjectResponseReceivedHandler copyResponseHandler;
HeadObjectResponseReceivedHandler headObjectResponseHandler;
std::shared_ptr<const Aws::Client::AsyncCallerContext> asyncCallerContext;
const Aws::AmazonWebServiceRequest* originalRequest;
std::shared_ptr<Aws::Http::HttpRequest> request;
Expand Down
1 change: 0 additions & 1 deletion generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtServiceClientModel.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -414,7 +414,6 @@ typedef std::future<GetObjectTaggingOutcome> GetObjectTaggingOutcomeCallable;
typedef std::future<GetObjectTorrentOutcome> GetObjectTorrentOutcomeCallable;
typedef std::future<GetPublicAccessBlockOutcome> GetPublicAccessBlockOutcomeCallable;
typedef std::future<HeadBucketOutcome> HeadBucketOutcomeCallable;
typedef std::future<HeadObjectOutcome> HeadObjectOutcomeCallable;
typedef std::future<ListBucketAnalyticsConfigurationsOutcome> ListBucketAnalyticsConfigurationsOutcomeCallable;
typedef std::future<ListBucketIntelligentTieringConfigurationsOutcome> ListBucketIntelligentTieringConfigurationsOutcomeCallable;
typedef std::future<ListBucketInventoryConfigurationsOutcome> ListBucketInventoryConfigurationsOutcomeCallable;
Expand Down
184 changes: 161 additions & 23 deletions generated/src/aws-cpp-sdk-s3-crt/source/S3CrtClient.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1212,7 +1212,7 @@ CopyObjectOutcome S3CrtClient::CopyObject(const CopyObjectRequest& request) cons
AWS_OPERATION_GUARD(CopyObject);
auto tracer = m_telemetryProvider->getTracer(this->GetServiceClientName(), {});
auto meter = m_telemetryProvider->getMeter(this->GetServiceClientName(), {});
AWS_OPERATION_CHECK_PTR(meter, GetObject, CoreErrors, CoreErrors::NOT_INITIALIZED);
AWS_OPERATION_CHECK_PTR(meter, CopyObject, CoreErrors, CoreErrors::NOT_INITIALIZED);
return TracingUtils::MakeCallWithTiming<CopyObjectOutcome>(
[&]() -> CopyObjectOutcome {
Aws::Utils::Threading::Semaphore sem(0, 1);
Expand Down Expand Up @@ -1394,6 +1394,165 @@ GetObjectOutcome S3CrtClient::GetObject(const GetObjectRequest& request) const {
{TracingUtils::SMITHY_SERVICE_DIMENSION, this->GetServiceClientName()}});
}

static void HeadObjectRequestShutdownCallback(void* user_data) {
if (!user_data) {
AWS_LOGSTREAM_ERROR("HeadObject", "user data passed is NULL ");
return;
}
auto* userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);

// call user callback and release user_data
S3Crt::Model::HeadObjectOutcome outcome(userData->s3CrtClient->GenerateXmlOutcome(userData->response));
// log into monitor
if (userData->asyncCallerContext) {
if (!outcome.IsSuccess()) {
userData->asyncCallerContext->GetMonitorContext().OnRequestFailed(userData->request, userData->response);
} else {
userData->asyncCallerContext->GetMonitorContext().OnRequestSucceeded(userData->request, userData->response);
}
}
userData->headObjectResponseHandler(userData->s3CrtClient, *(reinterpret_cast<const HeadObjectRequest*>(userData->originalRequest)),
std::move(outcome), userData->asyncCallerContext);

Aws::Delete(userData);
}

void S3CrtClient::HeadObjectAsync(const HeadObjectRequest& request, const HeadObjectResponseReceivedHandler& handler,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext) const {
AWS_ASYNC_OPERATION_GUARD(HeadObject);
if (!m_endpointProvider) {
return handler(this, request,
HeadObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INTERNAL_FAILURE, "INTERNAL_FAILURE",
"Endpoint provider is not initialized", false)),
handlerContext);
}
if (!request.BucketHasBeenSet()) {
AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Bucket, is not set");
return handler(this, request,
HeadObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER",
"Missing required field [Bucket]", false)),
handlerContext);
}
if (!request.KeyHasBeenSet()) {
AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Key, is not set");
return handler(this, request,
HeadObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER",
"Missing required field [Key]", false)),
handlerContext);
}
auto meter = m_telemetryProvider->getMeter(this->GetServiceClientName(), {});
auto endpointResolutionOutcome = TracingUtils::MakeCallWithTiming<ResolveEndpointOutcome>(
[&]() -> ResolveEndpointOutcome { return m_endpointProvider->ResolveEndpoint(request.GetEndpointContextParams()); },
TracingUtils::SMITHY_CLIENT_ENDPOINT_RESOLUTION_METRIC, *meter,
{{TracingUtils::SMITHY_METHOD_DIMENSION, request.GetServiceRequestName()},
{TracingUtils::SMITHY_SERVICE_DIMENSION, this->GetServiceClientName()}});
if (!endpointResolutionOutcome.IsSuccess()) {
handler(this, request,
HeadObjectOutcome(Aws::Client::AWSError<CoreErrors>(CoreErrors::ENDPOINT_RESOLUTION_FAILURE, "ENDPOINT_RESOLUTION_FAILURE",
endpointResolutionOutcome.GetError().GetMessage(), false)),
handlerContext);
return;
}
endpointResolutionOutcome.GetResult().AddPathSegments(request.GetKey());

request.SetServiceSpecificParameters([&]() -> std::shared_ptr<Http::ServiceSpecificParameters> {
Aws::Map<Aws::String, Aws::String> params;
params.emplace("bucketName", request.GetBucket());
ServiceSpecificParameters serviceSpecificParameters{params};
return Aws::MakeShared<ServiceSpecificParameters>(ALLOCATION_TAG, serviceSpecificParameters);
}());

// make aws_s3_meta_request with callbacks
CrtRequestCallbackUserData* userData = Aws::New<CrtRequestCallbackUserData>(ALLOCATION_TAG);
aws_s3_meta_request_options options;
AWS_ZERO_STRUCT(options);
aws_uri endpoint;
InitCrtEndpointFromUri(endpoint, endpointResolutionOutcome.GetResult().GetURI());
options.endpoint = &endpoint;
std::unique_ptr<aws_uri, void (*)(aws_uri*)> endpointCleanup{&endpoint, &aws_uri_clean_up};

userData->headObjectResponseHandler = handler;
if (handlerContext) {
userData->asyncCallerContext = handlerContext;
}
InitCommonCrtRequestOption(userData, &options, &request, endpointResolutionOutcome.GetResult().GetURI(),
Aws::Http::HttpMethod::HTTP_HEAD);
if (userData != nullptr && userData->request != nullptr && userData->request->GetContentBody() != nullptr &&
userData->request->GetContentBody()->fail()) {
}
if (handlerContext) {
handlerContext->GetMonitorContext().StartMonitorContext(Aws::String{"S3CrtClient"}, request.GetServiceRequestName(), userData->request);
}
options.shutdown_callback = HeadObjectRequestShutdownCallback;
options.type = AWS_S3_META_REQUEST_TYPE_DEFAULT;
options.operation_name = Aws::Crt::ByteCursorFromCString("HeadObject");
struct aws_signing_config_aws signing_config_override = m_s3CrtSigningConfig;
if (endpointResolutionOutcome.GetResult().GetAttributes() &&
endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetSigningRegion()) {
signing_config_override.region =
Aws::Crt::ByteCursorFromCString(endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetSigningRegion()->c_str());
}
if (endpointResolutionOutcome.GetResult().GetAttributes() &&
endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetSigningRegionSet()) {
signing_config_override.region =
Aws::Crt::ByteCursorFromCString(endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetSigningRegionSet()->c_str());
}
if (endpointResolutionOutcome.GetResult().GetAttributes() &&
endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetSigningName()) {
signing_config_override.service =
Aws::Crt::ByteCursorFromCString(endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetSigningName()->c_str());
}
if (endpointResolutionOutcome.GetResult().GetAttributes() &&
endpointResolutionOutcome.GetResult().GetAttributes()->authScheme.GetName() == "S3ExpressSigner") {
signing_config_override.algorithm = aws_signing_algorithm::AWS_SIGNING_ALGORITHM_V4_S3EXPRESS;
} else {
signing_config_override.algorithm = aws_signing_algorithm::AWS_SIGNING_ALGORITHM_V4;
}
options.signing_config = &signing_config_override;

std::shared_ptr<Aws::Crt::Http::HttpRequest> crtHttpRequest = userData->request->ToCrtHttpRequest();
options.message = crtHttpRequest->GetUnderlyingMessage();
userData->crtHttpRequest = crtHttpRequest;

aws_s3_meta_request* meta_request = aws_s3_client_make_meta_request(m_s3CrtClient, &options);
if (meta_request == nullptr) {
return handler(this, request,
HeadObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INTERNAL_FAILURE, "INTERNAL_FAILURE",
"Unable to create s3 meta request", false)),
handlerContext);
}
auto& shouldContinueFn = request.GetContinueRequestHandler();
const HttpRequest* httpRequest = userData->request ? userData->request.get() : nullptr;
if (shouldContinueFn && !shouldContinueFn(httpRequest)) {
aws_s3_meta_request_cancel(meta_request);
}
}

HeadObjectOutcome S3CrtClient::HeadObject(const HeadObjectRequest& request) const {
AWS_OPERATION_GUARD(HeadObject);
auto tracer = m_telemetryProvider->getTracer(this->GetServiceClientName(), {});
auto meter = m_telemetryProvider->getMeter(this->GetServiceClientName(), {});
AWS_OPERATION_CHECK_PTR(meter, HeadObject, CoreErrors, CoreErrors::NOT_INITIALIZED);
return TracingUtils::MakeCallWithTiming<HeadObjectOutcome>(
[&]() -> HeadObjectOutcome {
Aws::Utils::Threading::Semaphore sem(0, 1);
HeadObjectOutcome res;
auto handlerContext = Aws::MakeShared<AsyncCallerContext>(ALLOCATION_TAG);
auto handler = HeadObjectResponseReceivedHandler{[&](const S3CrtClient*, const HeadObjectRequest&, const HeadObjectOutcome& outcome,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) {
res = std::move(outcome);
sem.ReleaseAll();
}};

S3CrtClient::HeadObjectAsync(request, handler, handlerContext);
sem.WaitOne();
return res;
},
TracingUtils::SMITHY_CLIENT_DURATION_METRIC, *meter,
{{TracingUtils::SMITHY_METHOD_DIMENSION, request.GetServiceRequestName()},
{TracingUtils::SMITHY_SERVICE_DIMENSION, this->GetServiceClientName()}});
}

static void PutObjectRequestShutdownCallback(void* user_data) {
if (!user_data) {
AWS_LOGSTREAM_ERROR("PutObject", "user data passed is NULL ");
Expand Down Expand Up @@ -1568,7 +1727,7 @@ PutObjectOutcome S3CrtClient::PutObject(const PutObjectRequest& request) const {
AWS_OPERATION_GUARD(PutObject);
auto tracer = m_telemetryProvider->getTracer(this->GetServiceClientName(), {});
auto meter = m_telemetryProvider->getMeter(this->GetServiceClientName(), {});
AWS_OPERATION_CHECK_PTR(meter, GetObject, CoreErrors, CoreErrors::NOT_INITIALIZED);
AWS_OPERATION_CHECK_PTR(meter, PutObject, CoreErrors, CoreErrors::NOT_INITIALIZED);
return TracingUtils::MakeCallWithTiming<PutObjectOutcome>(
[&]() -> PutObjectOutcome {
Aws::Utils::Threading::Semaphore sem(0, 1);
Expand Down Expand Up @@ -2929,27 +3088,6 @@ HeadBucketOutcome S3CrtClient::HeadBucket(const HeadBucketRequest& request) cons
return result.IsSuccess() ? HeadBucketOutcome(result.GetResultWithOwnership()) : HeadBucketOutcome(std::move(result.GetError()));
}

HeadObjectOutcome S3CrtClient::HeadObject(const HeadObjectRequest& request) const {
if (!request.BucketHasBeenSet()) {
AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Bucket, is not set");
return HeadObjectOutcome(
Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
}
if (!request.KeyHasBeenSet()) {
AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Key, is not set");
return HeadObjectOutcome(
Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
}

auto uriResolver = [&](Aws::Endpoint::ResolveEndpointOutcome& endpointResolutionOutcome) {
(void)endpointResolutionOutcome;
endpointResolutionOutcome.GetResult().AddPathSegments(request.GetKey());
};

auto result = InvokeServiceOperation(request, uriResolver, request.GetBucket(), Aws::Http::HttpMethod::HTTP_HEAD);
return result.IsSuccess() ? HeadObjectOutcome(result.GetResultWithOwnership()) : HeadObjectOutcome(std::move(result.GetError()));
}

ListBucketAnalyticsConfigurationsOutcome S3CrtClient::ListBucketAnalyticsConfigurations(
const ListBucketAnalyticsConfigurationsRequest& request) const {
if (!request.BucketHasBeenSet()) {
Expand Down
12 changes: 3 additions & 9 deletions generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4692,20 +4692,14 @@ class AWS_S3_API S3Client : public Aws::Client::AWSXMLClient,
/**
* A Callable wrapper for HeadObject that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template <typename HeadObjectRequestT = Model::HeadObjectRequest>
Model::HeadObjectOutcomeCallable HeadObjectCallable(const HeadObjectRequestT& request) const {
return SubmitCallable(&S3Client::HeadObject, request);
}
virtual Model::HeadObjectOutcomeCallable HeadObjectCallable(const Model::HeadObjectRequest& request) const;

/**
* An Async wrapper for HeadObject that queues the request into a thread executor and triggers associated callback when operation has
* finished.
*/
template <typename HeadObjectRequestT = Model::HeadObjectRequest>
void HeadObjectAsync(const HeadObjectRequestT& request, const HeadObjectResponseReceivedHandler& handler,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
return SubmitAsync(&S3Client::HeadObject, request, handler, context);
}
virtual void HeadObjectAsync(const Model::HeadObjectRequest& request, const HeadObjectResponseReceivedHandler& handler,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

/**
* <p>This operation is not supported for directory buckets.</p>
Expand Down
13 changes: 13 additions & 0 deletions generated/src/aws-cpp-sdk-s3/source/S3Client.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1829,6 +1829,19 @@ HeadObjectOutcome S3Client::HeadObject(const HeadObjectRequest& request) const {
return result.IsSuccess() ? HeadObjectOutcome(result.GetResultWithOwnership()) : HeadObjectOutcome(std::move(result.GetError()));
}

HeadObjectOutcomeCallable S3Client::HeadObjectCallable(const HeadObjectRequest& request) const {
auto task =
Aws::MakeShared<std::packaged_task<HeadObjectOutcome()> >(ALLOCATION_TAG, [this, request]() { return this->HeadObject(request); });
auto packagedFunction = [task]() { (*task)(); };
m_clientConfiguration.executor->Submit(packagedFunction);
return task->get_future();
}

void S3Client::HeadObjectAsync(const HeadObjectRequest& request, const HeadObjectResponseReceivedHandler& handler,
const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const {
m_clientConfiguration.executor->Submit([this, request, handler, context]() { handler(this, request, HeadObject(request), context); });
}

ListBucketAnalyticsConfigurationsOutcome S3Client::ListBucketAnalyticsConfigurations(
const ListBucketAnalyticsConfigurationsRequest& request) const {
if (!request.BucketHasBeenSet()) {
Expand Down
Loading
Loading