1 /**
2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 * SPDX-License-Identifier: Apache-2.0.
4 */
5
6 #include <aws/core/utils/Outcome.h>
7 #include <aws/core/auth/AWSAuthSigner.h>
8 #include <aws/core/client/CoreErrors.h>
9 #include <aws/core/client/RetryStrategy.h>
10 #include <aws/core/http/HttpClient.h>
11 #include <aws/core/http/HttpResponse.h>
12 #include <aws/core/http/HttpClientFactory.h>
13 #include <aws/core/auth/AWSCredentialsProviderChain.h>
14 #include <aws/core/utils/xml/XmlSerializer.h>
15 #include <aws/core/utils/memory/stl/AWSStringStream.h>
16 #include <aws/core/utils/threading/Executor.h>
17 #include <aws/core/utils/DNS.h>
18 #include <aws/core/utils/logging/LogMacros.h>
19 #include <aws/core/utils/event/EventStream.h>
20 #include <aws/core/platform/Environment.h>
21
22 #include <aws/s3-crt/S3CrtClient.h>
23 #include <aws/s3-crt/S3CrtEndpoint.h>
24 #include <aws/s3-crt/S3CrtErrorMarshaller.h>
25 #include <aws/s3-crt/S3CrtARN.h>
26 #include <aws/s3-crt/model/AbortMultipartUploadRequest.h>
27 #include <aws/s3-crt/model/CompleteMultipartUploadRequest.h>
28 #include <aws/s3-crt/model/CopyObjectRequest.h>
29 #include <aws/s3-crt/model/CreateBucketRequest.h>
30 #include <aws/s3-crt/model/CreateMultipartUploadRequest.h>
31 #include <aws/s3-crt/model/DeleteBucketRequest.h>
32 #include <aws/s3-crt/model/DeleteBucketAnalyticsConfigurationRequest.h>
33 #include <aws/s3-crt/model/DeleteBucketCorsRequest.h>
34 #include <aws/s3-crt/model/DeleteBucketEncryptionRequest.h>
35 #include <aws/s3-crt/model/DeleteBucketIntelligentTieringConfigurationRequest.h>
36 #include <aws/s3-crt/model/DeleteBucketInventoryConfigurationRequest.h>
37 #include <aws/s3-crt/model/DeleteBucketLifecycleRequest.h>
38 #include <aws/s3-crt/model/DeleteBucketMetricsConfigurationRequest.h>
39 #include <aws/s3-crt/model/DeleteBucketOwnershipControlsRequest.h>
40 #include <aws/s3-crt/model/DeleteBucketPolicyRequest.h>
41 #include <aws/s3-crt/model/DeleteBucketReplicationRequest.h>
42 #include <aws/s3-crt/model/DeleteBucketTaggingRequest.h>
43 #include <aws/s3-crt/model/DeleteBucketWebsiteRequest.h>
44 #include <aws/s3-crt/model/DeleteObjectRequest.h>
45 #include <aws/s3-crt/model/DeleteObjectTaggingRequest.h>
46 #include <aws/s3-crt/model/DeleteObjectsRequest.h>
47 #include <aws/s3-crt/model/DeletePublicAccessBlockRequest.h>
48 #include <aws/s3-crt/model/GetBucketAccelerateConfigurationRequest.h>
49 #include <aws/s3-crt/model/GetBucketAclRequest.h>
50 #include <aws/s3-crt/model/GetBucketAnalyticsConfigurationRequest.h>
51 #include <aws/s3-crt/model/GetBucketCorsRequest.h>
52 #include <aws/s3-crt/model/GetBucketEncryptionRequest.h>
53 #include <aws/s3-crt/model/GetBucketIntelligentTieringConfigurationRequest.h>
54 #include <aws/s3-crt/model/GetBucketInventoryConfigurationRequest.h>
55 #include <aws/s3-crt/model/GetBucketLifecycleConfigurationRequest.h>
56 #include <aws/s3-crt/model/GetBucketLocationRequest.h>
57 #include <aws/s3-crt/model/GetBucketLoggingRequest.h>
58 #include <aws/s3-crt/model/GetBucketMetricsConfigurationRequest.h>
59 #include <aws/s3-crt/model/GetBucketNotificationConfigurationRequest.h>
60 #include <aws/s3-crt/model/GetBucketOwnershipControlsRequest.h>
61 #include <aws/s3-crt/model/GetBucketPolicyRequest.h>
62 #include <aws/s3-crt/model/GetBucketPolicyStatusRequest.h>
63 #include <aws/s3-crt/model/GetBucketReplicationRequest.h>
64 #include <aws/s3-crt/model/GetBucketRequestPaymentRequest.h>
65 #include <aws/s3-crt/model/GetBucketTaggingRequest.h>
66 #include <aws/s3-crt/model/GetBucketVersioningRequest.h>
67 #include <aws/s3-crt/model/GetBucketWebsiteRequest.h>
68 #include <aws/s3-crt/model/GetObjectRequest.h>
69 #include <aws/s3-crt/model/GetObjectAclRequest.h>
70 #include <aws/s3-crt/model/GetObjectLegalHoldRequest.h>
71 #include <aws/s3-crt/model/GetObjectLockConfigurationRequest.h>
72 #include <aws/s3-crt/model/GetObjectRetentionRequest.h>
73 #include <aws/s3-crt/model/GetObjectTaggingRequest.h>
74 #include <aws/s3-crt/model/GetObjectTorrentRequest.h>
75 #include <aws/s3-crt/model/GetPublicAccessBlockRequest.h>
76 #include <aws/s3-crt/model/HeadBucketRequest.h>
77 #include <aws/s3-crt/model/HeadObjectRequest.h>
78 #include <aws/s3-crt/model/ListBucketAnalyticsConfigurationsRequest.h>
79 #include <aws/s3-crt/model/ListBucketIntelligentTieringConfigurationsRequest.h>
80 #include <aws/s3-crt/model/ListBucketInventoryConfigurationsRequest.h>
81 #include <aws/s3-crt/model/ListBucketMetricsConfigurationsRequest.h>
82 #include <aws/s3-crt/model/ListMultipartUploadsRequest.h>
83 #include <aws/s3-crt/model/ListObjectVersionsRequest.h>
84 #include <aws/s3-crt/model/ListObjectsRequest.h>
85 #include <aws/s3-crt/model/ListObjectsV2Request.h>
86 #include <aws/s3-crt/model/ListPartsRequest.h>
87 #include <aws/s3-crt/model/PutBucketAccelerateConfigurationRequest.h>
88 #include <aws/s3-crt/model/PutBucketAclRequest.h>
89 #include <aws/s3-crt/model/PutBucketAnalyticsConfigurationRequest.h>
90 #include <aws/s3-crt/model/PutBucketCorsRequest.h>
91 #include <aws/s3-crt/model/PutBucketEncryptionRequest.h>
92 #include <aws/s3-crt/model/PutBucketIntelligentTieringConfigurationRequest.h>
93 #include <aws/s3-crt/model/PutBucketInventoryConfigurationRequest.h>
94 #include <aws/s3-crt/model/PutBucketLifecycleConfigurationRequest.h>
95 #include <aws/s3-crt/model/PutBucketLoggingRequest.h>
96 #include <aws/s3-crt/model/PutBucketMetricsConfigurationRequest.h>
97 #include <aws/s3-crt/model/PutBucketNotificationConfigurationRequest.h>
98 #include <aws/s3-crt/model/PutBucketOwnershipControlsRequest.h>
99 #include <aws/s3-crt/model/PutBucketPolicyRequest.h>
100 #include <aws/s3-crt/model/PutBucketReplicationRequest.h>
101 #include <aws/s3-crt/model/PutBucketRequestPaymentRequest.h>
102 #include <aws/s3-crt/model/PutBucketTaggingRequest.h>
103 #include <aws/s3-crt/model/PutBucketVersioningRequest.h>
104 #include <aws/s3-crt/model/PutBucketWebsiteRequest.h>
105 #include <aws/s3-crt/model/PutObjectRequest.h>
106 #include <aws/s3-crt/model/PutObjectAclRequest.h>
107 #include <aws/s3-crt/model/PutObjectLegalHoldRequest.h>
108 #include <aws/s3-crt/model/PutObjectLockConfigurationRequest.h>
109 #include <aws/s3-crt/model/PutObjectRetentionRequest.h>
110 #include <aws/s3-crt/model/PutObjectTaggingRequest.h>
111 #include <aws/s3-crt/model/PutPublicAccessBlockRequest.h>
112 #include <aws/s3-crt/model/RestoreObjectRequest.h>
113 #include <aws/s3-crt/model/SelectObjectContentRequest.h>
114 #include <aws/s3-crt/model/UploadPartRequest.h>
115 #include <aws/s3-crt/model/UploadPartCopyRequest.h>
116 #include <aws/s3-crt/model/WriteGetObjectResponseRequest.h>
117 #include <aws/core/Version.h>
118 #include <aws/core/platform/OSVersionInfo.h>
119 #include <aws/core/http/standard/StandardHttpResponse.h>
120 #include <aws/core/Globals.h>
121 #include <aws/crt/Types.h>
122 #include <aws/crt/auth/Credentials.h>
123 #include <aws/crt/http/HttpRequestResponse.h>
124 #include <aws/crt/io/Stream.h>
125 #include <aws/http/request_response.h>
126 #include <aws/common/string.h>
127
128 using namespace Aws::Utils;
129
130 using namespace Aws;
131 using namespace Aws::Auth;
132 using namespace Aws::Client;
133 using namespace Aws::S3Crt;
134 using namespace Aws::S3Crt::Model;
135 using namespace Aws::Http;
136 using namespace Aws::Utils::Xml;
137
138
139 static const char* SERVICE_NAME = "s3";
140 static const char* ALLOCATION_TAG = "S3CrtClient";
141
142
S3CrtClient(const S3Crt::ClientConfiguration & clientConfiguration,Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads,bool useVirtualAddressing,Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption)143 S3CrtClient::S3CrtClient(const S3Crt::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing, Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption) :
144 BASECLASS(clientConfiguration,
145 Aws::MakeShared<Aws::Auth::DefaultAuthSignerProvider>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
146 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region), signPayloads, false),
147 Aws::MakeShared<S3CrtErrorMarshaller>(ALLOCATION_TAG)),
148 m_executor(clientConfiguration.executor), m_useVirtualAddressing(useVirtualAddressing), m_USEast1RegionalEndpointOption(USEast1RegionalEndPointOption)
149 {
150 init(clientConfiguration);
151 }
152
S3CrtClient(const AWSCredentials & credentials,const S3Crt::ClientConfiguration & clientConfiguration,Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads,bool useVirtualAddressing,Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption)153 S3CrtClient::S3CrtClient(const AWSCredentials& credentials, const S3Crt::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing, Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption) :
154 BASECLASS(clientConfiguration,
155 Aws::MakeShared<Aws::Auth::DefaultAuthSignerProvider>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
156 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region), signPayloads, false),
157 Aws::MakeShared<S3CrtErrorMarshaller>(ALLOCATION_TAG)),
158 m_executor(clientConfiguration.executor), m_useVirtualAddressing(useVirtualAddressing), m_USEast1RegionalEndpointOption(USEast1RegionalEndPointOption)
159 {
160 init(clientConfiguration, &credentials);
161 }
162
S3CrtClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const S3Crt::ClientConfiguration & clientConfiguration,Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads,bool useVirtualAddressing,Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption)163 S3CrtClient::S3CrtClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
164 const S3Crt::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing, Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption) :
165 BASECLASS(clientConfiguration,
166 Aws::MakeShared<Aws::Auth::DefaultAuthSignerProvider>(ALLOCATION_TAG, credentialsProvider,
167 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region), signPayloads, false),
168 Aws::MakeShared<S3CrtErrorMarshaller>(ALLOCATION_TAG)),
169 m_executor(clientConfiguration.executor), m_useVirtualAddressing(useVirtualAddressing), m_USEast1RegionalEndpointOption(USEast1RegionalEndPointOption)
170 {
171 Aws::Auth::AWSCredentials credentials = credentialsProvider->GetAWSCredentials();
172 init(clientConfiguration, &credentials);
173 }
174
~S3CrtClient()175 S3CrtClient::~S3CrtClient()
176 {
177 aws_s3_client_release(m_s3CrtClient);
178 m_clientShutdownSem->WaitOne(); // Wait aws_s3_client shutdown
179 }
180
init(const S3Crt::ClientConfiguration & config,const Aws::Auth::AWSCredentials * credentials)181 void S3CrtClient::init(const S3Crt::ClientConfiguration& config, const Aws::Auth::AWSCredentials* credentials)
182 {
183 SetServiceClientName("S3");
184 LoadS3CrtSpecificConfig(config.profileName);
185 m_configScheme = SchemeMapper::ToString(config.scheme);
186 m_scheme = m_configScheme;
187 m_useDualStack = config.useDualStack;
188 if (config.endpointOverride.empty())
189 {
190 m_useCustomEndpoint = false;
191 m_baseUri = S3CrtEndpoint::ForRegion(config.region, config.useDualStack, m_USEast1RegionalEndpointOption == Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::REGIONAL);
192 }
193 else
194 {
195 m_useCustomEndpoint = true;
196 OverrideEndpoint(config.endpointOverride);
197 }
198 m_enableHostPrefixInjection = config.enableHostPrefixInjection;
199
200 // initialize aws_s3_client;
201 aws_s3_client_config s3CrtConfig;
202 memset(&s3CrtConfig, 0, sizeof(s3CrtConfig));
203 s3CrtConfig.region = Aws::Crt::ByteCursorFromCString(config.region.c_str());
204 Aws::Crt::Io::ClientBootstrap* clientBootstrap = config.clientBootstrap ? config.clientBootstrap.get() : Aws::GetDefaultClientBootstrap();
205 s3CrtConfig.client_bootstrap = clientBootstrap->GetUnderlyingHandle();
206
207 std::shared_ptr<Aws::Crt::Auth::ICredentialsProvider> provider(nullptr);
208 if (credentials)
209 {
210 Aws::Crt::Auth::CredentialsProviderStaticConfig staticCreds;
211 staticCreds.AccessKeyId = Aws::Crt::ByteCursorFromCString(credentials->GetAWSAccessKeyId().c_str());
212 staticCreds.SecretAccessKey = Aws::Crt::ByteCursorFromCString(credentials->GetAWSSecretKey().c_str());
213 staticCreds.SessionToken = Aws::Crt::ByteCursorFromCString(credentials->GetSessionToken().c_str());
214 provider = Aws::Crt::Auth::CredentialsProvider::CreateCredentialsProviderStatic(staticCreds);
215 }
216 else
217 {
218 Aws::Crt::Auth::CredentialsProviderChainDefaultConfig credsConfig;
219 credsConfig.Bootstrap = clientBootstrap;
220 provider = Aws::Crt::Auth::CredentialsProvider::CreateCredentialsProviderChainDefault(credsConfig);
221 }
222
223 aws_s3_init_default_signing_config(&m_s3CrtSigningConfig, Aws::Crt::ByteCursorFromCString(config.region.c_str()), provider->GetUnderlyingHandle());
224 m_s3CrtSigningConfig.flags.use_double_uri_encode = false;
225 s3CrtConfig.signing_config = &m_s3CrtSigningConfig;
226
227 static const size_t DEFAULT_PART_SIZE = 5 * 1024 * 1024; // 5MB
228 s3CrtConfig.part_size = config.partSize < DEFAULT_PART_SIZE ? DEFAULT_PART_SIZE : config.partSize;
229
230 Aws::Crt::Io::TlsConnectionOptions* tlsConnectionOptions = config.tlsConnectionOptions ? config.tlsConnectionOptions.get() : Aws::GetDefaultTlsConnectionOptions();
231 aws_tls_connection_options tlsOptions;
232 if (tlsConnectionOptions)
233 {
234 aws_tls_connection_options_copy(&tlsOptions, tlsConnectionOptions->GetUnderlyingHandle());
235 tlsOptions.server_name = aws_string_new_from_c_str(Aws::get_aws_allocator(), m_baseUri.c_str());
236 s3CrtConfig.tls_connection_options = &tlsOptions;
237 }
238 else
239 {
240 s3CrtConfig.tls_connection_options = nullptr;
241 }
242
243 s3CrtConfig.tls_mode = config.scheme == Aws::Http::Scheme::HTTPS ? AWS_MR_TLS_ENABLED : AWS_MR_TLS_DISABLED;
244 s3CrtConfig.throughput_target_gbps = config.throughputTargetGbps;
245 m_clientShutdownSem = Aws::MakeShared<Threading::Semaphore>(ALLOCATION_TAG, 0, 1);
246 m_wrappedData.data = config.shutdownCallbackUserData;
247 m_wrappedData.fn = config.clientShutdownCallback;
248 m_wrappedData.clientShutdownSem = m_clientShutdownSem;
249 s3CrtConfig.shutdown_callback = CrtClientShutdownCallback;
250 s3CrtConfig.shutdown_callback_user_data = static_cast<void*>(&m_wrappedData);
251
252 m_s3CrtClient = aws_s3_client_new(Aws::get_aws_allocator(), &s3CrtConfig);
253 if (tlsConnectionOptions)
254 {
255 aws_tls_connection_options_clean_up(&tlsOptions);
256 }
257 if (!m_s3CrtClient)
258 {
259 AWS_LOGSTREAM_FATAL(ALLOCATION_TAG, "Failed to allocate aws_s3_client instance, abort.");
260 }
261 }
262
OverrideEndpoint(const Aws::String & endpoint)263 void S3CrtClient::OverrideEndpoint(const Aws::String& endpoint)
264 {
265 if (endpoint.compare(0, 7, "http://") == 0)
266 {
267 m_scheme = "http";
268 m_baseUri = endpoint.substr(7);
269 }
270 else if (endpoint.compare(0, 8, "https://") == 0)
271 {
272 m_scheme = "https";
273 m_baseUri = endpoint.substr(8);
274 }
275 else
276 {
277 m_scheme = m_configScheme;
278 m_baseUri = endpoint;
279 }
280 }
281
282 static const int SUCCESS_RESPONSE_MIN = 200;
283 static const int SUCCESS_RESPONSE_MAX = 299;
284
DoesResponseGenerateError(const std::shared_ptr<HttpResponse> & response)285 static bool DoesResponseGenerateError(const std::shared_ptr<HttpResponse>& response)
286 {
287 if (response->HasClientError()) return true;
288
289 int responseCode = static_cast<int>(response->GetResponseCode());
290 return responseCode < SUCCESS_RESPONSE_MIN || responseCode > SUCCESS_RESPONSE_MAX;
291 }
292
S3CrtRequestHeadersCallback(struct aws_s3_meta_request * meta_request,const struct aws_http_headers * headers,int response_status,void * user_data)293 static int S3CrtRequestHeadersCallback(struct aws_s3_meta_request *meta_request, const struct aws_http_headers *headers,
294 int response_status, void *user_data)
295 {
296 AWS_UNREFERENCED_PARAM(meta_request);
297 auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
298 size_t headersCount = aws_http_headers_count(headers);
299 for (size_t i = 0; i < headersCount; i++)
300 {
301 struct aws_http_header header;
302 aws_http_headers_get_index(headers, i, &header);
303 userData->response->AddHeader(StringUtils::FromByteCursor(header.name), StringUtils::FromByteCursor(header.value));
304 }
305 userData->response->SetResponseCode(static_cast<HttpResponseCode>(response_status));
306 return AWS_OP_SUCCESS;
307 }
308
S3CrtRequestGetBodyCallback(struct aws_s3_meta_request * meta_request,const struct aws_byte_cursor * body,uint64_t range_start,void * user_data)309 static int S3CrtRequestGetBodyCallback(struct aws_s3_meta_request *meta_request, const struct aws_byte_cursor *body, uint64_t range_start, void *user_data)
310 {
311 AWS_UNREFERENCED_PARAM(meta_request);
312 AWS_UNREFERENCED_PARAM(range_start);
313
314 auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
315 auto& bodyStream = userData->response->GetResponseBody();
316
317 bodyStream.write(reinterpret_cast<char*>(body->ptr), static_cast<std::streamsize>(body->len));
318 if (userData->request->IsEventStreamRequest())
319 {
320 bodyStream.flush();
321 }
322
323 // data sent handler and continuation handler will be supported later when aws_c_s3 support it.
324 auto& receivedHandler = userData->request->GetDataReceivedEventHandler();
325 if (receivedHandler)
326 {
327 receivedHandler(userData->request.get(), userData->response.get(), static_cast<long long>(body->len));
328 }
329 AWS_LOGSTREAM_TRACE(ALLOCATION_TAG, body->len << " bytes written to response.");
330
331 return AWS_OP_SUCCESS;
332 }
333
S3CrtRequestFinishCallback(struct aws_s3_meta_request * meta_request,const struct aws_s3_meta_request_result * meta_request_result,void * user_data)334 static void S3CrtRequestFinishCallback(struct aws_s3_meta_request *meta_request,
335 const struct aws_s3_meta_request_result *meta_request_result, void *user_data)
336 {
337 AWS_UNREFERENCED_PARAM(meta_request);
338 auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
339 userData->response->SetResponseCode(static_cast<HttpResponseCode>(meta_request_result->response_status));
340 if (meta_request_result->error_response_headers)
341 {
342 size_t headersCount = aws_http_headers_count(meta_request_result->error_response_headers);
343 for (size_t i = 0; i < headersCount; i++)
344 {
345 struct aws_http_header header;
346 aws_http_headers_get_index(meta_request_result->error_response_headers, i, &header);
347 userData->response->AddHeader(StringUtils::FromByteCursor(header.name), StringUtils::FromByteCursor(header.value));
348 }
349 }
350
351 if (meta_request_result->error_code || meta_request_result->response_status != static_cast<int>(Aws::Http::HttpResponseCode::OK))
352 {
353 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "S3CrtClient received error response for s3_meta_request with response code: " << meta_request_result->response_status
354 << ", with error_code: " << meta_request_result->error_code);
355 }
356
357 auto& bodyStream = userData->response->GetResponseBody();
358
359 if (meta_request_result->error_response_body)
360 {
361 // clean up previously received body data.
362 bodyStream.seekg(0);
363 bodyStream.seekp(0);
364 bodyStream.write(reinterpret_cast<char*>(meta_request_result->error_response_body->buffer), static_cast<std::streamsize>(meta_request_result->error_response_body->len));
365 }
366
367 aws_s3_meta_request_release(userData->underlyingS3Request);
368 }
369
GenerateXmlOutcome(const std::shared_ptr<HttpResponse> & response) const370 Aws::Client::XmlOutcome S3CrtClient::GenerateXmlOutcome(const std::shared_ptr<HttpResponse>& response) const
371 {
372 Aws::Client::HttpResponseOutcome httpOutcome;
373 if (DoesResponseGenerateError(response))
374 {
375 AWS_LOGSTREAM_DEBUG(ALLOCATION_TAG, "Request returned error. Attempting to generate appropriate error codes from response");
376 auto error = BuildAWSError(response);
377 httpOutcome = HttpResponseOutcome(std::move(error));
378 }
379 else
380 {
381 httpOutcome = HttpResponseOutcome(std::move(response));
382 }
383
384 if (!httpOutcome.IsSuccess())
385 {
386 return XmlOutcome(std::move(httpOutcome));
387 }
388
389 if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
390 {
391 XmlDocument xmlDoc = XmlDocument::CreateFromXmlStream(httpOutcome.GetResult()->GetResponseBody());
392
393 if (!xmlDoc.WasParseSuccessful())
394 {
395 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Xml parsing for error failed with message " << xmlDoc.GetErrorMessage().c_str());
396 return AWSError<CoreErrors>(CoreErrors::UNKNOWN, "Xml Parse Error", xmlDoc.GetErrorMessage(), false);
397 }
398
399 return XmlOutcome(AmazonWebServiceResult<XmlDocument>(std::move(xmlDoc),
400 httpOutcome.GetResult()->GetHeaders(), httpOutcome.GetResult()->GetResponseCode()));
401 }
402
403 return XmlOutcome(AmazonWebServiceResult<XmlDocument>(XmlDocument(), httpOutcome.GetResult()->GetHeaders()));
404 }
405
GenerateStreamOutcome(const std::shared_ptr<Http::HttpResponse> & response) const406 Aws::Client::StreamOutcome S3CrtClient::GenerateStreamOutcome(const std::shared_ptr<Http::HttpResponse>& response) const
407 {
408 Aws::Client::HttpResponseOutcome httpOutcome;
409 if (DoesResponseGenerateError(response))
410 {
411 AWS_LOGSTREAM_DEBUG(ALLOCATION_TAG, "Request returned error. Attempting to generate appropriate error codes from response");
412 auto error = BuildAWSError(response);
413 httpOutcome = HttpResponseOutcome(std::move(error));
414 }
415 else
416 {
417 httpOutcome = HttpResponseOutcome(std::move(response));
418 }
419
420 if (httpOutcome.IsSuccess())
421 {
422 return StreamOutcome(AmazonWebServiceResult<Stream::ResponseStream>(
423 httpOutcome.GetResult()->SwapResponseStreamOwnership(),
424 httpOutcome.GetResult()->GetHeaders(), httpOutcome.GetResult()->GetResponseCode()));
425 }
426
427 return StreamOutcome(std::move(httpOutcome));
428 }
429
InitCommonCrtRequestOption(CrtRequestCallbackUserData * userData,aws_s3_meta_request_options * options,const Aws::AmazonWebServiceRequest * request,const Aws::Http::URI & uri,Aws::Http::HttpMethod method) const430 void S3CrtClient::InitCommonCrtRequestOption(CrtRequestCallbackUserData *userData, aws_s3_meta_request_options *options, const Aws::AmazonWebServiceRequest *request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method) const
431 {
432 std::shared_ptr<HttpRequest> httpRequest(nullptr);
433 if (request)
434 {
435 httpRequest = CreateHttpRequest(uri, method, request->GetResponseStreamFactory());
436 BuildHttpRequest(*request, httpRequest);
437 }
438 else
439 {
440 httpRequest = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
441 }
442
443 std::shared_ptr<HttpResponse> httpResponse = Aws::MakeShared<Aws::Http::Standard::StandardHttpResponse>(ALLOCATION_TAG, httpRequest);
444
445 userData->s3CrtClient = this;
446 userData->originalRequest = request;
447 userData->request = httpRequest;
448 userData->response = httpResponse;
449
450 options->user_data = static_cast<void*>(userData);
451 options->headers_callback = S3CrtRequestHeadersCallback;
452 options->body_callback = S3CrtRequestGetBodyCallback;
453 options->finish_callback = S3CrtRequestFinishCallback;
454 }
455
GetObjectRequestShutdownCallback(void * user_data)456 static void GetObjectRequestShutdownCallback(void *user_data)
457 {
458 auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
459 // call user callback and release user_data
460 S3Crt::Model::GetObjectOutcome outcome(userData->s3CrtClient->GenerateStreamOutcome(userData->response));
461 auto handler = static_cast<const GetObjectResponseReceivedHandler*>(userData->userCallback);
462 (*handler)(userData->s3CrtClient, *(reinterpret_cast<const GetObjectRequest*>(userData->originalRequest)), std::move(outcome), userData->userCallbackContext);
463
464 Aws::Delete(userData);
465 }
466
GetObjectAsync(const GetObjectRequest & request,const GetObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const467 void S3CrtClient::GetObjectAsync(const GetObjectRequest& request, const GetObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
468 {
469 if (!request.BucketHasBeenSet())
470 {
471 AWS_LOGSTREAM_ERROR("GetObject", "Required field: Bucket, is not set");
472 return handler(this, request, GetObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)), context);
473 }
474 if (!request.KeyHasBeenSet())
475 {
476 AWS_LOGSTREAM_ERROR("GetObject", "Required field: Key, is not set");
477 return handler(this, request, GetObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)), context);
478 }
479 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
480 if (!computeEndpointOutcome.IsSuccess())
481 {
482 return handler(this, request, GetObjectOutcome(computeEndpointOutcome.GetError()), context);
483 }
484 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
485 uri.AddPathSegments(request.GetKey());
486
487 // make aws_s3_meta_request with callbacks
488 CrtRequestCallbackUserData *userData = Aws::New<CrtRequestCallbackUserData>(ALLOCATION_TAG);
489 aws_s3_meta_request_options options;
490 AWS_ZERO_STRUCT(options);
491
492 userData->userCallback = static_cast<const void*>(&handler);
493 userData->userCallbackContext = context;
494 InitCommonCrtRequestOption(userData, &options, &request, uri, Aws::Http::HttpMethod::HTTP_GET);
495 options.shutdown_callback = GetObjectRequestShutdownCallback;
496 options.type = AWS_S3_META_REQUEST_TYPE_GET_OBJECT;
497 struct aws_signing_config_aws signing_config_override = m_s3CrtSigningConfig;
498 signing_config_override.region = Aws::Crt::ByteCursorFromCString(computeEndpointOutcome.GetResult().signerRegion.c_str());
499 signing_config_override.service = Aws::Crt::ByteCursorFromCString(computeEndpointOutcome.GetResult().signerServiceName.c_str());
500 options.signing_config = &signing_config_override;
501
502 std::shared_ptr<Aws::Crt::Http::HttpRequest> crtHttpRequest = userData->request->ToCrtHttpRequest();
503 options.message= crtHttpRequest->GetUnderlyingMessage();
504 userData->crtHttpRequest = crtHttpRequest;
505 aws_s3_meta_request *rawRequest = aws_s3_client_make_meta_request(m_s3CrtClient, &options);
506 userData->underlyingS3Request = rawRequest;
507 }
508
GetObject(const GetObjectRequest & request) const509 GetObjectOutcome S3CrtClient::GetObject(const GetObjectRequest& request) const
510 {
511 Aws::Utils::Threading::Semaphore sem(0, 1);
512 GetObjectOutcome res;
513
514 auto handler = GetObjectResponseReceivedHandler{[&](const S3CrtClient*, const GetObjectRequest&, GetObjectOutcome outcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext> &) {
515 res = std::move(outcome);
516 sem.ReleaseAll();
517 }};
518
519 S3CrtClient::GetObjectAsync(request, handler, nullptr);
520 sem.WaitOne();
521 return res;
522 }
523
PutObjectRequestShutdownCallback(void * user_data)524 static void PutObjectRequestShutdownCallback(void *user_data)
525 {
526 auto *userData = static_cast<S3CrtClient::CrtRequestCallbackUserData*>(user_data);
527 // call user callback and release user_data
528 S3Crt::Model::PutObjectOutcome outcome(userData->s3CrtClient->GenerateXmlOutcome(userData->response));
529 auto handler = static_cast<const PutObjectResponseReceivedHandler*>(userData->userCallback);
530 (*handler)(userData->s3CrtClient, *(reinterpret_cast<const PutObjectRequest*>(userData->originalRequest)), std::move(outcome), userData->userCallbackContext);
531
532 Aws::Delete(userData);
533 }
534
PutObjectAsync(const PutObjectRequest & request,const PutObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const535 void S3CrtClient::PutObjectAsync(const PutObjectRequest& request, const PutObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
536 {
537 if (!request.BucketHasBeenSet())
538 {
539 AWS_LOGSTREAM_ERROR("PutObject", "Required field: Bucket, is not set");
540 return handler(this, request, PutObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)), context);
541 }
542 if (!request.KeyHasBeenSet())
543 {
544 AWS_LOGSTREAM_ERROR("PutObject", "Required field: Key, is not set");
545 return handler(this, request, PutObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)), context);
546 }
547 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
548 if (!computeEndpointOutcome.IsSuccess())
549 {
550 return handler(this, request, PutObjectOutcome(computeEndpointOutcome.GetError()), context);
551 }
552 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
553 uri.AddPathSegments(request.GetKey());
554
555 // make aws_s3_meta_request with callbacks
556 CrtRequestCallbackUserData *userData = Aws::New<CrtRequestCallbackUserData>(ALLOCATION_TAG);
557 aws_s3_meta_request_options options;
558 AWS_ZERO_STRUCT(options);
559
560 userData->userCallback = static_cast<const void*>(&handler);
561 userData->userCallbackContext = context;
562 InitCommonCrtRequestOption(userData, &options, &request, uri, Aws::Http::HttpMethod::HTTP_PUT);
563 options.shutdown_callback = PutObjectRequestShutdownCallback;
564 options.type = AWS_S3_META_REQUEST_TYPE_PUT_OBJECT;
565 struct aws_signing_config_aws signing_config_override = m_s3CrtSigningConfig;
566 signing_config_override.region = Aws::Crt::ByteCursorFromCString(computeEndpointOutcome.GetResult().signerRegion.c_str());
567 signing_config_override.service = Aws::Crt::ByteCursorFromCString(computeEndpointOutcome.GetResult().signerServiceName.c_str());
568 options.signing_config = &signing_config_override;
569
570 std::shared_ptr<Aws::Crt::Http::HttpRequest> crtHttpRequest = userData->request->ToCrtHttpRequest();
571 options.message= crtHttpRequest->GetUnderlyingMessage();
572 userData->crtHttpRequest = crtHttpRequest;
573 aws_s3_meta_request *rawRequest = aws_s3_client_make_meta_request(m_s3CrtClient, &options);
574 userData->underlyingS3Request = rawRequest;
575 }
576
PutObject(const PutObjectRequest & request) const577 PutObjectOutcome S3CrtClient::PutObject(const PutObjectRequest& request) const
578 {
579 Aws::Utils::Threading::Semaphore sem(0, 1);
580 PutObjectOutcome res;
581
582 auto handler = PutObjectResponseReceivedHandler{[&](const S3CrtClient*, const PutObjectRequest&, const PutObjectOutcome& outcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext> &) {
583 res = std::move(outcome);
584 sem.ReleaseAll();
585 }};
586
587 S3CrtClient::PutObjectAsync(request, handler, nullptr);
588 sem.WaitOne();
589 return res;
590 }
591
AbortMultipartUpload(const AbortMultipartUploadRequest & request) const592 AbortMultipartUploadOutcome S3CrtClient::AbortMultipartUpload(const AbortMultipartUploadRequest& request) const
593 {
594 if (!request.BucketHasBeenSet())
595 {
596 AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: Bucket, is not set");
597 return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
598 }
599 if (!request.KeyHasBeenSet())
600 {
601 AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: Key, is not set");
602 return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
603 }
604 if (!request.UploadIdHasBeenSet())
605 {
606 AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: UploadId, is not set");
607 return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
608 }
609 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
610 if (!computeEndpointOutcome.IsSuccess())
611 {
612 return AbortMultipartUploadOutcome(computeEndpointOutcome.GetError());
613 }
614 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
615 uri.AddPathSegments(request.GetKey());
616 return AbortMultipartUploadOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
617 }
618
AbortMultipartUploadCallable(const AbortMultipartUploadRequest & request) const619 AbortMultipartUploadOutcomeCallable S3CrtClient::AbortMultipartUploadCallable(const AbortMultipartUploadRequest& request) const
620 {
621 auto task = Aws::MakeShared< std::packaged_task< AbortMultipartUploadOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AbortMultipartUpload(request); } );
622 auto packagedFunction = [task]() { (*task)(); };
623 m_executor->Submit(packagedFunction);
624 return task->get_future();
625 }
626
AbortMultipartUploadAsync(const AbortMultipartUploadRequest & request,const AbortMultipartUploadResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const627 void S3CrtClient::AbortMultipartUploadAsync(const AbortMultipartUploadRequest& request, const AbortMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
628 {
629 m_executor->Submit( [this, request, handler, context](){ this->AbortMultipartUploadAsyncHelper( request, handler, context ); } );
630 }
631
AbortMultipartUploadAsyncHelper(const AbortMultipartUploadRequest & request,const AbortMultipartUploadResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const632 void S3CrtClient::AbortMultipartUploadAsyncHelper(const AbortMultipartUploadRequest& request, const AbortMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
633 {
634 handler(this, request, AbortMultipartUpload(request), context);
635 }
636
CompleteMultipartUpload(const CompleteMultipartUploadRequest & request) const637 CompleteMultipartUploadOutcome S3CrtClient::CompleteMultipartUpload(const CompleteMultipartUploadRequest& request) const
638 {
639 if (!request.BucketHasBeenSet())
640 {
641 AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: Bucket, is not set");
642 return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
643 }
644 if (!request.KeyHasBeenSet())
645 {
646 AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: Key, is not set");
647 return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
648 }
649 if (!request.UploadIdHasBeenSet())
650 {
651 AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: UploadId, is not set");
652 return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
653 }
654 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
655 if (!computeEndpointOutcome.IsSuccess())
656 {
657 return CompleteMultipartUploadOutcome(computeEndpointOutcome.GetError());
658 }
659 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
660 uri.AddPathSegments(request.GetKey());
661 return CompleteMultipartUploadOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
662 }
663
CompleteMultipartUploadCallable(const CompleteMultipartUploadRequest & request) const664 CompleteMultipartUploadOutcomeCallable S3CrtClient::CompleteMultipartUploadCallable(const CompleteMultipartUploadRequest& request) const
665 {
666 auto task = Aws::MakeShared< std::packaged_task< CompleteMultipartUploadOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CompleteMultipartUpload(request); } );
667 auto packagedFunction = [task]() { (*task)(); };
668 m_executor->Submit(packagedFunction);
669 return task->get_future();
670 }
671
CompleteMultipartUploadAsync(const CompleteMultipartUploadRequest & request,const CompleteMultipartUploadResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const672 void S3CrtClient::CompleteMultipartUploadAsync(const CompleteMultipartUploadRequest& request, const CompleteMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
673 {
674 m_executor->Submit( [this, request, handler, context](){ this->CompleteMultipartUploadAsyncHelper( request, handler, context ); } );
675 }
676
CompleteMultipartUploadAsyncHelper(const CompleteMultipartUploadRequest & request,const CompleteMultipartUploadResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const677 void S3CrtClient::CompleteMultipartUploadAsyncHelper(const CompleteMultipartUploadRequest& request, const CompleteMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
678 {
679 handler(this, request, CompleteMultipartUpload(request), context);
680 }
681
CopyObject(const CopyObjectRequest & request) const682 CopyObjectOutcome S3CrtClient::CopyObject(const CopyObjectRequest& request) const
683 {
684 if (!request.BucketHasBeenSet())
685 {
686 AWS_LOGSTREAM_ERROR("CopyObject", "Required field: Bucket, is not set");
687 return CopyObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
688 }
689 if (!request.CopySourceHasBeenSet())
690 {
691 AWS_LOGSTREAM_ERROR("CopyObject", "Required field: CopySource, is not set");
692 return CopyObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CopySource]", false));
693 }
694 if (!request.KeyHasBeenSet())
695 {
696 AWS_LOGSTREAM_ERROR("CopyObject", "Required field: Key, is not set");
697 return CopyObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
698 }
699 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
700 if (!computeEndpointOutcome.IsSuccess())
701 {
702 return CopyObjectOutcome(computeEndpointOutcome.GetError());
703 }
704 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
705 uri.AddPathSegments(request.GetKey());
706 return CopyObjectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
707 }
708
CopyObjectCallable(const CopyObjectRequest & request) const709 CopyObjectOutcomeCallable S3CrtClient::CopyObjectCallable(const CopyObjectRequest& request) const
710 {
711 auto task = Aws::MakeShared< std::packaged_task< CopyObjectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CopyObject(request); } );
712 auto packagedFunction = [task]() { (*task)(); };
713 m_executor->Submit(packagedFunction);
714 return task->get_future();
715 }
716
CopyObjectAsync(const CopyObjectRequest & request,const CopyObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const717 void S3CrtClient::CopyObjectAsync(const CopyObjectRequest& request, const CopyObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
718 {
719 m_executor->Submit( [this, request, handler, context](){ this->CopyObjectAsyncHelper( request, handler, context ); } );
720 }
721
CopyObjectAsyncHelper(const CopyObjectRequest & request,const CopyObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const722 void S3CrtClient::CopyObjectAsyncHelper(const CopyObjectRequest& request, const CopyObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
723 {
724 handler(this, request, CopyObject(request), context);
725 }
726
CreateBucket(const CreateBucketRequest & request) const727 CreateBucketOutcome S3CrtClient::CreateBucket(const CreateBucketRequest& request) const
728 {
729 if (!request.BucketHasBeenSet())
730 {
731 AWS_LOGSTREAM_ERROR("CreateBucket", "Required field: Bucket, is not set");
732 return CreateBucketOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
733 }
734 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString();
735 if (!computeEndpointOutcome.IsSuccess())
736 {
737 return CreateBucketOutcome(computeEndpointOutcome.GetError());
738 }
739 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
740 uri.AddPathSegment(request.GetBucket());
741 return CreateBucketOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
742 }
743
CreateBucketCallable(const CreateBucketRequest & request) const744 CreateBucketOutcomeCallable S3CrtClient::CreateBucketCallable(const CreateBucketRequest& request) const
745 {
746 auto task = Aws::MakeShared< std::packaged_task< CreateBucketOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateBucket(request); } );
747 auto packagedFunction = [task]() { (*task)(); };
748 m_executor->Submit(packagedFunction);
749 return task->get_future();
750 }
751
CreateBucketAsync(const CreateBucketRequest & request,const CreateBucketResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const752 void S3CrtClient::CreateBucketAsync(const CreateBucketRequest& request, const CreateBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
753 {
754 m_executor->Submit( [this, request, handler, context](){ this->CreateBucketAsyncHelper( request, handler, context ); } );
755 }
756
CreateBucketAsyncHelper(const CreateBucketRequest & request,const CreateBucketResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const757 void S3CrtClient::CreateBucketAsyncHelper(const CreateBucketRequest& request, const CreateBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
758 {
759 handler(this, request, CreateBucket(request), context);
760 }
761
CreateMultipartUpload(const CreateMultipartUploadRequest & request) const762 CreateMultipartUploadOutcome S3CrtClient::CreateMultipartUpload(const CreateMultipartUploadRequest& request) const
763 {
764 if (!request.BucketHasBeenSet())
765 {
766 AWS_LOGSTREAM_ERROR("CreateMultipartUpload", "Required field: Bucket, is not set");
767 return CreateMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
768 }
769 if (!request.KeyHasBeenSet())
770 {
771 AWS_LOGSTREAM_ERROR("CreateMultipartUpload", "Required field: Key, is not set");
772 return CreateMultipartUploadOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
773 }
774 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
775 if (!computeEndpointOutcome.IsSuccess())
776 {
777 return CreateMultipartUploadOutcome(computeEndpointOutcome.GetError());
778 }
779 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
780 Aws::StringStream ss;
781 uri.AddPathSegments(request.GetKey());
782 ss.str("?uploads");
783 uri.SetQueryString(ss.str());
784 return CreateMultipartUploadOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
785 }
786
CreateMultipartUploadCallable(const CreateMultipartUploadRequest & request) const787 CreateMultipartUploadOutcomeCallable S3CrtClient::CreateMultipartUploadCallable(const CreateMultipartUploadRequest& request) const
788 {
789 auto task = Aws::MakeShared< std::packaged_task< CreateMultipartUploadOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMultipartUpload(request); } );
790 auto packagedFunction = [task]() { (*task)(); };
791 m_executor->Submit(packagedFunction);
792 return task->get_future();
793 }
794
CreateMultipartUploadAsync(const CreateMultipartUploadRequest & request,const CreateMultipartUploadResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const795 void S3CrtClient::CreateMultipartUploadAsync(const CreateMultipartUploadRequest& request, const CreateMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
796 {
797 m_executor->Submit( [this, request, handler, context](){ this->CreateMultipartUploadAsyncHelper( request, handler, context ); } );
798 }
799
CreateMultipartUploadAsyncHelper(const CreateMultipartUploadRequest & request,const CreateMultipartUploadResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const800 void S3CrtClient::CreateMultipartUploadAsyncHelper(const CreateMultipartUploadRequest& request, const CreateMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
801 {
802 handler(this, request, CreateMultipartUpload(request), context);
803 }
804
DeleteBucket(const DeleteBucketRequest & request) const805 DeleteBucketOutcome S3CrtClient::DeleteBucket(const DeleteBucketRequest& request) const
806 {
807 if (!request.BucketHasBeenSet())
808 {
809 AWS_LOGSTREAM_ERROR("DeleteBucket", "Required field: Bucket, is not set");
810 return DeleteBucketOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
811 }
812 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
813 if (!computeEndpointOutcome.IsSuccess())
814 {
815 return DeleteBucketOutcome(computeEndpointOutcome.GetError());
816 }
817 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
818 return DeleteBucketOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
819 }
820
DeleteBucketCallable(const DeleteBucketRequest & request) const821 DeleteBucketOutcomeCallable S3CrtClient::DeleteBucketCallable(const DeleteBucketRequest& request) const
822 {
823 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucket(request); } );
824 auto packagedFunction = [task]() { (*task)(); };
825 m_executor->Submit(packagedFunction);
826 return task->get_future();
827 }
828
DeleteBucketAsync(const DeleteBucketRequest & request,const DeleteBucketResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const829 void S3CrtClient::DeleteBucketAsync(const DeleteBucketRequest& request, const DeleteBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
830 {
831 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketAsyncHelper( request, handler, context ); } );
832 }
833
DeleteBucketAsyncHelper(const DeleteBucketRequest & request,const DeleteBucketResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const834 void S3CrtClient::DeleteBucketAsyncHelper(const DeleteBucketRequest& request, const DeleteBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
835 {
836 handler(this, request, DeleteBucket(request), context);
837 }
838
DeleteBucketAnalyticsConfiguration(const DeleteBucketAnalyticsConfigurationRequest & request) const839 DeleteBucketAnalyticsConfigurationOutcome S3CrtClient::DeleteBucketAnalyticsConfiguration(const DeleteBucketAnalyticsConfigurationRequest& request) const
840 {
841 if (!request.BucketHasBeenSet())
842 {
843 AWS_LOGSTREAM_ERROR("DeleteBucketAnalyticsConfiguration", "Required field: Bucket, is not set");
844 return DeleteBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
845 }
846 if (!request.IdHasBeenSet())
847 {
848 AWS_LOGSTREAM_ERROR("DeleteBucketAnalyticsConfiguration", "Required field: Id, is not set");
849 return DeleteBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
850 }
851 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
852 if (!computeEndpointOutcome.IsSuccess())
853 {
854 return DeleteBucketAnalyticsConfigurationOutcome(computeEndpointOutcome.GetError());
855 }
856 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
857 Aws::StringStream ss;
858 ss.str("?analytics");
859 uri.SetQueryString(ss.str());
860 return DeleteBucketAnalyticsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
861 }
862
DeleteBucketAnalyticsConfigurationCallable(const DeleteBucketAnalyticsConfigurationRequest & request) const863 DeleteBucketAnalyticsConfigurationOutcomeCallable S3CrtClient::DeleteBucketAnalyticsConfigurationCallable(const DeleteBucketAnalyticsConfigurationRequest& request) const
864 {
865 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketAnalyticsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketAnalyticsConfiguration(request); } );
866 auto packagedFunction = [task]() { (*task)(); };
867 m_executor->Submit(packagedFunction);
868 return task->get_future();
869 }
870
DeleteBucketAnalyticsConfigurationAsync(const DeleteBucketAnalyticsConfigurationRequest & request,const DeleteBucketAnalyticsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const871 void S3CrtClient::DeleteBucketAnalyticsConfigurationAsync(const DeleteBucketAnalyticsConfigurationRequest& request, const DeleteBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
872 {
873 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketAnalyticsConfigurationAsyncHelper( request, handler, context ); } );
874 }
875
DeleteBucketAnalyticsConfigurationAsyncHelper(const DeleteBucketAnalyticsConfigurationRequest & request,const DeleteBucketAnalyticsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const876 void S3CrtClient::DeleteBucketAnalyticsConfigurationAsyncHelper(const DeleteBucketAnalyticsConfigurationRequest& request, const DeleteBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
877 {
878 handler(this, request, DeleteBucketAnalyticsConfiguration(request), context);
879 }
880
DeleteBucketCors(const DeleteBucketCorsRequest & request) const881 DeleteBucketCorsOutcome S3CrtClient::DeleteBucketCors(const DeleteBucketCorsRequest& request) const
882 {
883 if (!request.BucketHasBeenSet())
884 {
885 AWS_LOGSTREAM_ERROR("DeleteBucketCors", "Required field: Bucket, is not set");
886 return DeleteBucketCorsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
887 }
888 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
889 if (!computeEndpointOutcome.IsSuccess())
890 {
891 return DeleteBucketCorsOutcome(computeEndpointOutcome.GetError());
892 }
893 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
894 Aws::StringStream ss;
895 ss.str("?cors");
896 uri.SetQueryString(ss.str());
897 return DeleteBucketCorsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
898 }
899
DeleteBucketCorsCallable(const DeleteBucketCorsRequest & request) const900 DeleteBucketCorsOutcomeCallable S3CrtClient::DeleteBucketCorsCallable(const DeleteBucketCorsRequest& request) const
901 {
902 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketCorsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketCors(request); } );
903 auto packagedFunction = [task]() { (*task)(); };
904 m_executor->Submit(packagedFunction);
905 return task->get_future();
906 }
907
DeleteBucketCorsAsync(const DeleteBucketCorsRequest & request,const DeleteBucketCorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const908 void S3CrtClient::DeleteBucketCorsAsync(const DeleteBucketCorsRequest& request, const DeleteBucketCorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
909 {
910 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketCorsAsyncHelper( request, handler, context ); } );
911 }
912
DeleteBucketCorsAsyncHelper(const DeleteBucketCorsRequest & request,const DeleteBucketCorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const913 void S3CrtClient::DeleteBucketCorsAsyncHelper(const DeleteBucketCorsRequest& request, const DeleteBucketCorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
914 {
915 handler(this, request, DeleteBucketCors(request), context);
916 }
917
DeleteBucketEncryption(const DeleteBucketEncryptionRequest & request) const918 DeleteBucketEncryptionOutcome S3CrtClient::DeleteBucketEncryption(const DeleteBucketEncryptionRequest& request) const
919 {
920 if (!request.BucketHasBeenSet())
921 {
922 AWS_LOGSTREAM_ERROR("DeleteBucketEncryption", "Required field: Bucket, is not set");
923 return DeleteBucketEncryptionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
924 }
925 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
926 if (!computeEndpointOutcome.IsSuccess())
927 {
928 return DeleteBucketEncryptionOutcome(computeEndpointOutcome.GetError());
929 }
930 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
931 Aws::StringStream ss;
932 ss.str("?encryption");
933 uri.SetQueryString(ss.str());
934 return DeleteBucketEncryptionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
935 }
936
DeleteBucketEncryptionCallable(const DeleteBucketEncryptionRequest & request) const937 DeleteBucketEncryptionOutcomeCallable S3CrtClient::DeleteBucketEncryptionCallable(const DeleteBucketEncryptionRequest& request) const
938 {
939 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketEncryptionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketEncryption(request); } );
940 auto packagedFunction = [task]() { (*task)(); };
941 m_executor->Submit(packagedFunction);
942 return task->get_future();
943 }
944
DeleteBucketEncryptionAsync(const DeleteBucketEncryptionRequest & request,const DeleteBucketEncryptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const945 void S3CrtClient::DeleteBucketEncryptionAsync(const DeleteBucketEncryptionRequest& request, const DeleteBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
946 {
947 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketEncryptionAsyncHelper( request, handler, context ); } );
948 }
949
DeleteBucketEncryptionAsyncHelper(const DeleteBucketEncryptionRequest & request,const DeleteBucketEncryptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const950 void S3CrtClient::DeleteBucketEncryptionAsyncHelper(const DeleteBucketEncryptionRequest& request, const DeleteBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
951 {
952 handler(this, request, DeleteBucketEncryption(request), context);
953 }
954
DeleteBucketIntelligentTieringConfiguration(const DeleteBucketIntelligentTieringConfigurationRequest & request) const955 DeleteBucketIntelligentTieringConfigurationOutcome S3CrtClient::DeleteBucketIntelligentTieringConfiguration(const DeleteBucketIntelligentTieringConfigurationRequest& request) const
956 {
957 if (!request.BucketHasBeenSet())
958 {
959 AWS_LOGSTREAM_ERROR("DeleteBucketIntelligentTieringConfiguration", "Required field: Bucket, is not set");
960 return DeleteBucketIntelligentTieringConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
961 }
962 if (!request.IdHasBeenSet())
963 {
964 AWS_LOGSTREAM_ERROR("DeleteBucketIntelligentTieringConfiguration", "Required field: Id, is not set");
965 return DeleteBucketIntelligentTieringConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
966 }
967 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
968 if (!computeEndpointOutcome.IsSuccess())
969 {
970 return DeleteBucketIntelligentTieringConfigurationOutcome(computeEndpointOutcome.GetError());
971 }
972 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
973 Aws::StringStream ss;
974 ss.str("?intelligent-tiering");
975 uri.SetQueryString(ss.str());
976 return DeleteBucketIntelligentTieringConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
977 }
978
DeleteBucketIntelligentTieringConfigurationCallable(const DeleteBucketIntelligentTieringConfigurationRequest & request) const979 DeleteBucketIntelligentTieringConfigurationOutcomeCallable S3CrtClient::DeleteBucketIntelligentTieringConfigurationCallable(const DeleteBucketIntelligentTieringConfigurationRequest& request) const
980 {
981 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketIntelligentTieringConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketIntelligentTieringConfiguration(request); } );
982 auto packagedFunction = [task]() { (*task)(); };
983 m_executor->Submit(packagedFunction);
984 return task->get_future();
985 }
986
DeleteBucketIntelligentTieringConfigurationAsync(const DeleteBucketIntelligentTieringConfigurationRequest & request,const DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const987 void S3CrtClient::DeleteBucketIntelligentTieringConfigurationAsync(const DeleteBucketIntelligentTieringConfigurationRequest& request, const DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
988 {
989 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketIntelligentTieringConfigurationAsyncHelper( request, handler, context ); } );
990 }
991
DeleteBucketIntelligentTieringConfigurationAsyncHelper(const DeleteBucketIntelligentTieringConfigurationRequest & request,const DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const992 void S3CrtClient::DeleteBucketIntelligentTieringConfigurationAsyncHelper(const DeleteBucketIntelligentTieringConfigurationRequest& request, const DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
993 {
994 handler(this, request, DeleteBucketIntelligentTieringConfiguration(request), context);
995 }
996
DeleteBucketInventoryConfiguration(const DeleteBucketInventoryConfigurationRequest & request) const997 DeleteBucketInventoryConfigurationOutcome S3CrtClient::DeleteBucketInventoryConfiguration(const DeleteBucketInventoryConfigurationRequest& request) const
998 {
999 if (!request.BucketHasBeenSet())
1000 {
1001 AWS_LOGSTREAM_ERROR("DeleteBucketInventoryConfiguration", "Required field: Bucket, is not set");
1002 return DeleteBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1003 }
1004 if (!request.IdHasBeenSet())
1005 {
1006 AWS_LOGSTREAM_ERROR("DeleteBucketInventoryConfiguration", "Required field: Id, is not set");
1007 return DeleteBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1008 }
1009 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1010 if (!computeEndpointOutcome.IsSuccess())
1011 {
1012 return DeleteBucketInventoryConfigurationOutcome(computeEndpointOutcome.GetError());
1013 }
1014 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1015 Aws::StringStream ss;
1016 ss.str("?inventory");
1017 uri.SetQueryString(ss.str());
1018 return DeleteBucketInventoryConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1019 }
1020
DeleteBucketInventoryConfigurationCallable(const DeleteBucketInventoryConfigurationRequest & request) const1021 DeleteBucketInventoryConfigurationOutcomeCallable S3CrtClient::DeleteBucketInventoryConfigurationCallable(const DeleteBucketInventoryConfigurationRequest& request) const
1022 {
1023 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketInventoryConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketInventoryConfiguration(request); } );
1024 auto packagedFunction = [task]() { (*task)(); };
1025 m_executor->Submit(packagedFunction);
1026 return task->get_future();
1027 }
1028
DeleteBucketInventoryConfigurationAsync(const DeleteBucketInventoryConfigurationRequest & request,const DeleteBucketInventoryConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1029 void S3CrtClient::DeleteBucketInventoryConfigurationAsync(const DeleteBucketInventoryConfigurationRequest& request, const DeleteBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1030 {
1031 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketInventoryConfigurationAsyncHelper( request, handler, context ); } );
1032 }
1033
DeleteBucketInventoryConfigurationAsyncHelper(const DeleteBucketInventoryConfigurationRequest & request,const DeleteBucketInventoryConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1034 void S3CrtClient::DeleteBucketInventoryConfigurationAsyncHelper(const DeleteBucketInventoryConfigurationRequest& request, const DeleteBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1035 {
1036 handler(this, request, DeleteBucketInventoryConfiguration(request), context);
1037 }
1038
DeleteBucketLifecycle(const DeleteBucketLifecycleRequest & request) const1039 DeleteBucketLifecycleOutcome S3CrtClient::DeleteBucketLifecycle(const DeleteBucketLifecycleRequest& request) const
1040 {
1041 if (!request.BucketHasBeenSet())
1042 {
1043 AWS_LOGSTREAM_ERROR("DeleteBucketLifecycle", "Required field: Bucket, is not set");
1044 return DeleteBucketLifecycleOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1045 }
1046 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1047 if (!computeEndpointOutcome.IsSuccess())
1048 {
1049 return DeleteBucketLifecycleOutcome(computeEndpointOutcome.GetError());
1050 }
1051 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1052 Aws::StringStream ss;
1053 ss.str("?lifecycle");
1054 uri.SetQueryString(ss.str());
1055 return DeleteBucketLifecycleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1056 }
1057
DeleteBucketLifecycleCallable(const DeleteBucketLifecycleRequest & request) const1058 DeleteBucketLifecycleOutcomeCallable S3CrtClient::DeleteBucketLifecycleCallable(const DeleteBucketLifecycleRequest& request) const
1059 {
1060 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketLifecycleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketLifecycle(request); } );
1061 auto packagedFunction = [task]() { (*task)(); };
1062 m_executor->Submit(packagedFunction);
1063 return task->get_future();
1064 }
1065
DeleteBucketLifecycleAsync(const DeleteBucketLifecycleRequest & request,const DeleteBucketLifecycleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1066 void S3CrtClient::DeleteBucketLifecycleAsync(const DeleteBucketLifecycleRequest& request, const DeleteBucketLifecycleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1067 {
1068 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketLifecycleAsyncHelper( request, handler, context ); } );
1069 }
1070
DeleteBucketLifecycleAsyncHelper(const DeleteBucketLifecycleRequest & request,const DeleteBucketLifecycleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1071 void S3CrtClient::DeleteBucketLifecycleAsyncHelper(const DeleteBucketLifecycleRequest& request, const DeleteBucketLifecycleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1072 {
1073 handler(this, request, DeleteBucketLifecycle(request), context);
1074 }
1075
DeleteBucketMetricsConfiguration(const DeleteBucketMetricsConfigurationRequest & request) const1076 DeleteBucketMetricsConfigurationOutcome S3CrtClient::DeleteBucketMetricsConfiguration(const DeleteBucketMetricsConfigurationRequest& request) const
1077 {
1078 if (!request.BucketHasBeenSet())
1079 {
1080 AWS_LOGSTREAM_ERROR("DeleteBucketMetricsConfiguration", "Required field: Bucket, is not set");
1081 return DeleteBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1082 }
1083 if (!request.IdHasBeenSet())
1084 {
1085 AWS_LOGSTREAM_ERROR("DeleteBucketMetricsConfiguration", "Required field: Id, is not set");
1086 return DeleteBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1087 }
1088 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1089 if (!computeEndpointOutcome.IsSuccess())
1090 {
1091 return DeleteBucketMetricsConfigurationOutcome(computeEndpointOutcome.GetError());
1092 }
1093 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1094 Aws::StringStream ss;
1095 ss.str("?metrics");
1096 uri.SetQueryString(ss.str());
1097 return DeleteBucketMetricsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1098 }
1099
DeleteBucketMetricsConfigurationCallable(const DeleteBucketMetricsConfigurationRequest & request) const1100 DeleteBucketMetricsConfigurationOutcomeCallable S3CrtClient::DeleteBucketMetricsConfigurationCallable(const DeleteBucketMetricsConfigurationRequest& request) const
1101 {
1102 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketMetricsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketMetricsConfiguration(request); } );
1103 auto packagedFunction = [task]() { (*task)(); };
1104 m_executor->Submit(packagedFunction);
1105 return task->get_future();
1106 }
1107
DeleteBucketMetricsConfigurationAsync(const DeleteBucketMetricsConfigurationRequest & request,const DeleteBucketMetricsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1108 void S3CrtClient::DeleteBucketMetricsConfigurationAsync(const DeleteBucketMetricsConfigurationRequest& request, const DeleteBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1109 {
1110 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketMetricsConfigurationAsyncHelper( request, handler, context ); } );
1111 }
1112
DeleteBucketMetricsConfigurationAsyncHelper(const DeleteBucketMetricsConfigurationRequest & request,const DeleteBucketMetricsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1113 void S3CrtClient::DeleteBucketMetricsConfigurationAsyncHelper(const DeleteBucketMetricsConfigurationRequest& request, const DeleteBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1114 {
1115 handler(this, request, DeleteBucketMetricsConfiguration(request), context);
1116 }
1117
DeleteBucketOwnershipControls(const DeleteBucketOwnershipControlsRequest & request) const1118 DeleteBucketOwnershipControlsOutcome S3CrtClient::DeleteBucketOwnershipControls(const DeleteBucketOwnershipControlsRequest& request) const
1119 {
1120 if (!request.BucketHasBeenSet())
1121 {
1122 AWS_LOGSTREAM_ERROR("DeleteBucketOwnershipControls", "Required field: Bucket, is not set");
1123 return DeleteBucketOwnershipControlsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1124 }
1125 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1126 if (!computeEndpointOutcome.IsSuccess())
1127 {
1128 return DeleteBucketOwnershipControlsOutcome(computeEndpointOutcome.GetError());
1129 }
1130 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1131 Aws::StringStream ss;
1132 ss.str("?ownershipControls");
1133 uri.SetQueryString(ss.str());
1134 return DeleteBucketOwnershipControlsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1135 }
1136
DeleteBucketOwnershipControlsCallable(const DeleteBucketOwnershipControlsRequest & request) const1137 DeleteBucketOwnershipControlsOutcomeCallable S3CrtClient::DeleteBucketOwnershipControlsCallable(const DeleteBucketOwnershipControlsRequest& request) const
1138 {
1139 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketOwnershipControlsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketOwnershipControls(request); } );
1140 auto packagedFunction = [task]() { (*task)(); };
1141 m_executor->Submit(packagedFunction);
1142 return task->get_future();
1143 }
1144
DeleteBucketOwnershipControlsAsync(const DeleteBucketOwnershipControlsRequest & request,const DeleteBucketOwnershipControlsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1145 void S3CrtClient::DeleteBucketOwnershipControlsAsync(const DeleteBucketOwnershipControlsRequest& request, const DeleteBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1146 {
1147 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketOwnershipControlsAsyncHelper( request, handler, context ); } );
1148 }
1149
DeleteBucketOwnershipControlsAsyncHelper(const DeleteBucketOwnershipControlsRequest & request,const DeleteBucketOwnershipControlsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1150 void S3CrtClient::DeleteBucketOwnershipControlsAsyncHelper(const DeleteBucketOwnershipControlsRequest& request, const DeleteBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1151 {
1152 handler(this, request, DeleteBucketOwnershipControls(request), context);
1153 }
1154
DeleteBucketPolicy(const DeleteBucketPolicyRequest & request) const1155 DeleteBucketPolicyOutcome S3CrtClient::DeleteBucketPolicy(const DeleteBucketPolicyRequest& request) const
1156 {
1157 if (!request.BucketHasBeenSet())
1158 {
1159 AWS_LOGSTREAM_ERROR("DeleteBucketPolicy", "Required field: Bucket, is not set");
1160 return DeleteBucketPolicyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1161 }
1162 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1163 if (!computeEndpointOutcome.IsSuccess())
1164 {
1165 return DeleteBucketPolicyOutcome(computeEndpointOutcome.GetError());
1166 }
1167 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1168 Aws::StringStream ss;
1169 ss.str("?policy");
1170 uri.SetQueryString(ss.str());
1171 return DeleteBucketPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1172 }
1173
DeleteBucketPolicyCallable(const DeleteBucketPolicyRequest & request) const1174 DeleteBucketPolicyOutcomeCallable S3CrtClient::DeleteBucketPolicyCallable(const DeleteBucketPolicyRequest& request) const
1175 {
1176 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketPolicy(request); } );
1177 auto packagedFunction = [task]() { (*task)(); };
1178 m_executor->Submit(packagedFunction);
1179 return task->get_future();
1180 }
1181
DeleteBucketPolicyAsync(const DeleteBucketPolicyRequest & request,const DeleteBucketPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1182 void S3CrtClient::DeleteBucketPolicyAsync(const DeleteBucketPolicyRequest& request, const DeleteBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1183 {
1184 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketPolicyAsyncHelper( request, handler, context ); } );
1185 }
1186
DeleteBucketPolicyAsyncHelper(const DeleteBucketPolicyRequest & request,const DeleteBucketPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1187 void S3CrtClient::DeleteBucketPolicyAsyncHelper(const DeleteBucketPolicyRequest& request, const DeleteBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1188 {
1189 handler(this, request, DeleteBucketPolicy(request), context);
1190 }
1191
DeleteBucketReplication(const DeleteBucketReplicationRequest & request) const1192 DeleteBucketReplicationOutcome S3CrtClient::DeleteBucketReplication(const DeleteBucketReplicationRequest& request) const
1193 {
1194 if (!request.BucketHasBeenSet())
1195 {
1196 AWS_LOGSTREAM_ERROR("DeleteBucketReplication", "Required field: Bucket, is not set");
1197 return DeleteBucketReplicationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1198 }
1199 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1200 if (!computeEndpointOutcome.IsSuccess())
1201 {
1202 return DeleteBucketReplicationOutcome(computeEndpointOutcome.GetError());
1203 }
1204 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1205 Aws::StringStream ss;
1206 ss.str("?replication");
1207 uri.SetQueryString(ss.str());
1208 return DeleteBucketReplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1209 }
1210
DeleteBucketReplicationCallable(const DeleteBucketReplicationRequest & request) const1211 DeleteBucketReplicationOutcomeCallable S3CrtClient::DeleteBucketReplicationCallable(const DeleteBucketReplicationRequest& request) const
1212 {
1213 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketReplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketReplication(request); } );
1214 auto packagedFunction = [task]() { (*task)(); };
1215 m_executor->Submit(packagedFunction);
1216 return task->get_future();
1217 }
1218
DeleteBucketReplicationAsync(const DeleteBucketReplicationRequest & request,const DeleteBucketReplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1219 void S3CrtClient::DeleteBucketReplicationAsync(const DeleteBucketReplicationRequest& request, const DeleteBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1220 {
1221 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketReplicationAsyncHelper( request, handler, context ); } );
1222 }
1223
DeleteBucketReplicationAsyncHelper(const DeleteBucketReplicationRequest & request,const DeleteBucketReplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1224 void S3CrtClient::DeleteBucketReplicationAsyncHelper(const DeleteBucketReplicationRequest& request, const DeleteBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1225 {
1226 handler(this, request, DeleteBucketReplication(request), context);
1227 }
1228
DeleteBucketTagging(const DeleteBucketTaggingRequest & request) const1229 DeleteBucketTaggingOutcome S3CrtClient::DeleteBucketTagging(const DeleteBucketTaggingRequest& request) const
1230 {
1231 if (!request.BucketHasBeenSet())
1232 {
1233 AWS_LOGSTREAM_ERROR("DeleteBucketTagging", "Required field: Bucket, is not set");
1234 return DeleteBucketTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1235 }
1236 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1237 if (!computeEndpointOutcome.IsSuccess())
1238 {
1239 return DeleteBucketTaggingOutcome(computeEndpointOutcome.GetError());
1240 }
1241 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1242 Aws::StringStream ss;
1243 ss.str("?tagging");
1244 uri.SetQueryString(ss.str());
1245 return DeleteBucketTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1246 }
1247
DeleteBucketTaggingCallable(const DeleteBucketTaggingRequest & request) const1248 DeleteBucketTaggingOutcomeCallable S3CrtClient::DeleteBucketTaggingCallable(const DeleteBucketTaggingRequest& request) const
1249 {
1250 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketTaggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketTagging(request); } );
1251 auto packagedFunction = [task]() { (*task)(); };
1252 m_executor->Submit(packagedFunction);
1253 return task->get_future();
1254 }
1255
DeleteBucketTaggingAsync(const DeleteBucketTaggingRequest & request,const DeleteBucketTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1256 void S3CrtClient::DeleteBucketTaggingAsync(const DeleteBucketTaggingRequest& request, const DeleteBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1257 {
1258 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketTaggingAsyncHelper( request, handler, context ); } );
1259 }
1260
DeleteBucketTaggingAsyncHelper(const DeleteBucketTaggingRequest & request,const DeleteBucketTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1261 void S3CrtClient::DeleteBucketTaggingAsyncHelper(const DeleteBucketTaggingRequest& request, const DeleteBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1262 {
1263 handler(this, request, DeleteBucketTagging(request), context);
1264 }
1265
DeleteBucketWebsite(const DeleteBucketWebsiteRequest & request) const1266 DeleteBucketWebsiteOutcome S3CrtClient::DeleteBucketWebsite(const DeleteBucketWebsiteRequest& request) const
1267 {
1268 if (!request.BucketHasBeenSet())
1269 {
1270 AWS_LOGSTREAM_ERROR("DeleteBucketWebsite", "Required field: Bucket, is not set");
1271 return DeleteBucketWebsiteOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1272 }
1273 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1274 if (!computeEndpointOutcome.IsSuccess())
1275 {
1276 return DeleteBucketWebsiteOutcome(computeEndpointOutcome.GetError());
1277 }
1278 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1279 Aws::StringStream ss;
1280 ss.str("?website");
1281 uri.SetQueryString(ss.str());
1282 return DeleteBucketWebsiteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1283 }
1284
DeleteBucketWebsiteCallable(const DeleteBucketWebsiteRequest & request) const1285 DeleteBucketWebsiteOutcomeCallable S3CrtClient::DeleteBucketWebsiteCallable(const DeleteBucketWebsiteRequest& request) const
1286 {
1287 auto task = Aws::MakeShared< std::packaged_task< DeleteBucketWebsiteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteBucketWebsite(request); } );
1288 auto packagedFunction = [task]() { (*task)(); };
1289 m_executor->Submit(packagedFunction);
1290 return task->get_future();
1291 }
1292
DeleteBucketWebsiteAsync(const DeleteBucketWebsiteRequest & request,const DeleteBucketWebsiteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1293 void S3CrtClient::DeleteBucketWebsiteAsync(const DeleteBucketWebsiteRequest& request, const DeleteBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1294 {
1295 m_executor->Submit( [this, request, handler, context](){ this->DeleteBucketWebsiteAsyncHelper( request, handler, context ); } );
1296 }
1297
DeleteBucketWebsiteAsyncHelper(const DeleteBucketWebsiteRequest & request,const DeleteBucketWebsiteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1298 void S3CrtClient::DeleteBucketWebsiteAsyncHelper(const DeleteBucketWebsiteRequest& request, const DeleteBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1299 {
1300 handler(this, request, DeleteBucketWebsite(request), context);
1301 }
1302
DeleteObject(const DeleteObjectRequest & request) const1303 DeleteObjectOutcome S3CrtClient::DeleteObject(const DeleteObjectRequest& request) const
1304 {
1305 if (!request.BucketHasBeenSet())
1306 {
1307 AWS_LOGSTREAM_ERROR("DeleteObject", "Required field: Bucket, is not set");
1308 return DeleteObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1309 }
1310 if (!request.KeyHasBeenSet())
1311 {
1312 AWS_LOGSTREAM_ERROR("DeleteObject", "Required field: Key, is not set");
1313 return DeleteObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
1314 }
1315 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1316 if (!computeEndpointOutcome.IsSuccess())
1317 {
1318 return DeleteObjectOutcome(computeEndpointOutcome.GetError());
1319 }
1320 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1321 uri.AddPathSegments(request.GetKey());
1322 return DeleteObjectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1323 }
1324
DeleteObjectCallable(const DeleteObjectRequest & request) const1325 DeleteObjectOutcomeCallable S3CrtClient::DeleteObjectCallable(const DeleteObjectRequest& request) const
1326 {
1327 auto task = Aws::MakeShared< std::packaged_task< DeleteObjectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteObject(request); } );
1328 auto packagedFunction = [task]() { (*task)(); };
1329 m_executor->Submit(packagedFunction);
1330 return task->get_future();
1331 }
1332
DeleteObjectAsync(const DeleteObjectRequest & request,const DeleteObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1333 void S3CrtClient::DeleteObjectAsync(const DeleteObjectRequest& request, const DeleteObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1334 {
1335 m_executor->Submit( [this, request, handler, context](){ this->DeleteObjectAsyncHelper( request, handler, context ); } );
1336 }
1337
DeleteObjectAsyncHelper(const DeleteObjectRequest & request,const DeleteObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1338 void S3CrtClient::DeleteObjectAsyncHelper(const DeleteObjectRequest& request, const DeleteObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1339 {
1340 handler(this, request, DeleteObject(request), context);
1341 }
1342
DeleteObjectTagging(const DeleteObjectTaggingRequest & request) const1343 DeleteObjectTaggingOutcome S3CrtClient::DeleteObjectTagging(const DeleteObjectTaggingRequest& request) const
1344 {
1345 if (!request.BucketHasBeenSet())
1346 {
1347 AWS_LOGSTREAM_ERROR("DeleteObjectTagging", "Required field: Bucket, is not set");
1348 return DeleteObjectTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1349 }
1350 if (!request.KeyHasBeenSet())
1351 {
1352 AWS_LOGSTREAM_ERROR("DeleteObjectTagging", "Required field: Key, is not set");
1353 return DeleteObjectTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
1354 }
1355 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1356 if (!computeEndpointOutcome.IsSuccess())
1357 {
1358 return DeleteObjectTaggingOutcome(computeEndpointOutcome.GetError());
1359 }
1360 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1361 Aws::StringStream ss;
1362 uri.AddPathSegments(request.GetKey());
1363 ss.str("?tagging");
1364 uri.SetQueryString(ss.str());
1365 return DeleteObjectTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1366 }
1367
DeleteObjectTaggingCallable(const DeleteObjectTaggingRequest & request) const1368 DeleteObjectTaggingOutcomeCallable S3CrtClient::DeleteObjectTaggingCallable(const DeleteObjectTaggingRequest& request) const
1369 {
1370 auto task = Aws::MakeShared< std::packaged_task< DeleteObjectTaggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteObjectTagging(request); } );
1371 auto packagedFunction = [task]() { (*task)(); };
1372 m_executor->Submit(packagedFunction);
1373 return task->get_future();
1374 }
1375
DeleteObjectTaggingAsync(const DeleteObjectTaggingRequest & request,const DeleteObjectTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1376 void S3CrtClient::DeleteObjectTaggingAsync(const DeleteObjectTaggingRequest& request, const DeleteObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1377 {
1378 m_executor->Submit( [this, request, handler, context](){ this->DeleteObjectTaggingAsyncHelper( request, handler, context ); } );
1379 }
1380
DeleteObjectTaggingAsyncHelper(const DeleteObjectTaggingRequest & request,const DeleteObjectTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1381 void S3CrtClient::DeleteObjectTaggingAsyncHelper(const DeleteObjectTaggingRequest& request, const DeleteObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1382 {
1383 handler(this, request, DeleteObjectTagging(request), context);
1384 }
1385
DeleteObjects(const DeleteObjectsRequest & request) const1386 DeleteObjectsOutcome S3CrtClient::DeleteObjects(const DeleteObjectsRequest& request) const
1387 {
1388 if (!request.BucketHasBeenSet())
1389 {
1390 AWS_LOGSTREAM_ERROR("DeleteObjects", "Required field: Bucket, is not set");
1391 return DeleteObjectsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1392 }
1393 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1394 if (!computeEndpointOutcome.IsSuccess())
1395 {
1396 return DeleteObjectsOutcome(computeEndpointOutcome.GetError());
1397 }
1398 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1399 Aws::StringStream ss;
1400 ss.str("?delete");
1401 uri.SetQueryString(ss.str());
1402 return DeleteObjectsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1403 }
1404
DeleteObjectsCallable(const DeleteObjectsRequest & request) const1405 DeleteObjectsOutcomeCallable S3CrtClient::DeleteObjectsCallable(const DeleteObjectsRequest& request) const
1406 {
1407 auto task = Aws::MakeShared< std::packaged_task< DeleteObjectsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteObjects(request); } );
1408 auto packagedFunction = [task]() { (*task)(); };
1409 m_executor->Submit(packagedFunction);
1410 return task->get_future();
1411 }
1412
DeleteObjectsAsync(const DeleteObjectsRequest & request,const DeleteObjectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1413 void S3CrtClient::DeleteObjectsAsync(const DeleteObjectsRequest& request, const DeleteObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1414 {
1415 m_executor->Submit( [this, request, handler, context](){ this->DeleteObjectsAsyncHelper( request, handler, context ); } );
1416 }
1417
DeleteObjectsAsyncHelper(const DeleteObjectsRequest & request,const DeleteObjectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1418 void S3CrtClient::DeleteObjectsAsyncHelper(const DeleteObjectsRequest& request, const DeleteObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1419 {
1420 handler(this, request, DeleteObjects(request), context);
1421 }
1422
DeletePublicAccessBlock(const DeletePublicAccessBlockRequest & request) const1423 DeletePublicAccessBlockOutcome S3CrtClient::DeletePublicAccessBlock(const DeletePublicAccessBlockRequest& request) const
1424 {
1425 if (!request.BucketHasBeenSet())
1426 {
1427 AWS_LOGSTREAM_ERROR("DeletePublicAccessBlock", "Required field: Bucket, is not set");
1428 return DeletePublicAccessBlockOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1429 }
1430 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1431 if (!computeEndpointOutcome.IsSuccess())
1432 {
1433 return DeletePublicAccessBlockOutcome(computeEndpointOutcome.GetError());
1434 }
1435 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1436 Aws::StringStream ss;
1437 ss.str("?publicAccessBlock");
1438 uri.SetQueryString(ss.str());
1439 return DeletePublicAccessBlockOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1440 }
1441
DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequest & request) const1442 DeletePublicAccessBlockOutcomeCallable S3CrtClient::DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequest& request) const
1443 {
1444 auto task = Aws::MakeShared< std::packaged_task< DeletePublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePublicAccessBlock(request); } );
1445 auto packagedFunction = [task]() { (*task)(); };
1446 m_executor->Submit(packagedFunction);
1447 return task->get_future();
1448 }
1449
DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequest & request,const DeletePublicAccessBlockResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1450 void S3CrtClient::DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequest& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1451 {
1452 m_executor->Submit( [this, request, handler, context](){ this->DeletePublicAccessBlockAsyncHelper( request, handler, context ); } );
1453 }
1454
DeletePublicAccessBlockAsyncHelper(const DeletePublicAccessBlockRequest & request,const DeletePublicAccessBlockResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1455 void S3CrtClient::DeletePublicAccessBlockAsyncHelper(const DeletePublicAccessBlockRequest& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1456 {
1457 handler(this, request, DeletePublicAccessBlock(request), context);
1458 }
1459
GetBucketAccelerateConfiguration(const GetBucketAccelerateConfigurationRequest & request) const1460 GetBucketAccelerateConfigurationOutcome S3CrtClient::GetBucketAccelerateConfiguration(const GetBucketAccelerateConfigurationRequest& request) const
1461 {
1462 if (!request.BucketHasBeenSet())
1463 {
1464 AWS_LOGSTREAM_ERROR("GetBucketAccelerateConfiguration", "Required field: Bucket, is not set");
1465 return GetBucketAccelerateConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1466 }
1467 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1468 if (!computeEndpointOutcome.IsSuccess())
1469 {
1470 return GetBucketAccelerateConfigurationOutcome(computeEndpointOutcome.GetError());
1471 }
1472 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1473 Aws::StringStream ss;
1474 ss.str("?accelerate");
1475 uri.SetQueryString(ss.str());
1476 return GetBucketAccelerateConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1477 }
1478
GetBucketAccelerateConfigurationCallable(const GetBucketAccelerateConfigurationRequest & request) const1479 GetBucketAccelerateConfigurationOutcomeCallable S3CrtClient::GetBucketAccelerateConfigurationCallable(const GetBucketAccelerateConfigurationRequest& request) const
1480 {
1481 auto task = Aws::MakeShared< std::packaged_task< GetBucketAccelerateConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketAccelerateConfiguration(request); } );
1482 auto packagedFunction = [task]() { (*task)(); };
1483 m_executor->Submit(packagedFunction);
1484 return task->get_future();
1485 }
1486
GetBucketAccelerateConfigurationAsync(const GetBucketAccelerateConfigurationRequest & request,const GetBucketAccelerateConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1487 void S3CrtClient::GetBucketAccelerateConfigurationAsync(const GetBucketAccelerateConfigurationRequest& request, const GetBucketAccelerateConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1488 {
1489 m_executor->Submit( [this, request, handler, context](){ this->GetBucketAccelerateConfigurationAsyncHelper( request, handler, context ); } );
1490 }
1491
GetBucketAccelerateConfigurationAsyncHelper(const GetBucketAccelerateConfigurationRequest & request,const GetBucketAccelerateConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1492 void S3CrtClient::GetBucketAccelerateConfigurationAsyncHelper(const GetBucketAccelerateConfigurationRequest& request, const GetBucketAccelerateConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1493 {
1494 handler(this, request, GetBucketAccelerateConfiguration(request), context);
1495 }
1496
GetBucketAcl(const GetBucketAclRequest & request) const1497 GetBucketAclOutcome S3CrtClient::GetBucketAcl(const GetBucketAclRequest& request) const
1498 {
1499 if (!request.BucketHasBeenSet())
1500 {
1501 AWS_LOGSTREAM_ERROR("GetBucketAcl", "Required field: Bucket, is not set");
1502 return GetBucketAclOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1503 }
1504 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1505 if (!computeEndpointOutcome.IsSuccess())
1506 {
1507 return GetBucketAclOutcome(computeEndpointOutcome.GetError());
1508 }
1509 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1510 Aws::StringStream ss;
1511 ss.str("?acl");
1512 uri.SetQueryString(ss.str());
1513 return GetBucketAclOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1514 }
1515
GetBucketAclCallable(const GetBucketAclRequest & request) const1516 GetBucketAclOutcomeCallable S3CrtClient::GetBucketAclCallable(const GetBucketAclRequest& request) const
1517 {
1518 auto task = Aws::MakeShared< std::packaged_task< GetBucketAclOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketAcl(request); } );
1519 auto packagedFunction = [task]() { (*task)(); };
1520 m_executor->Submit(packagedFunction);
1521 return task->get_future();
1522 }
1523
GetBucketAclAsync(const GetBucketAclRequest & request,const GetBucketAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1524 void S3CrtClient::GetBucketAclAsync(const GetBucketAclRequest& request, const GetBucketAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1525 {
1526 m_executor->Submit( [this, request, handler, context](){ this->GetBucketAclAsyncHelper( request, handler, context ); } );
1527 }
1528
GetBucketAclAsyncHelper(const GetBucketAclRequest & request,const GetBucketAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1529 void S3CrtClient::GetBucketAclAsyncHelper(const GetBucketAclRequest& request, const GetBucketAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1530 {
1531 handler(this, request, GetBucketAcl(request), context);
1532 }
1533
GetBucketAnalyticsConfiguration(const GetBucketAnalyticsConfigurationRequest & request) const1534 GetBucketAnalyticsConfigurationOutcome S3CrtClient::GetBucketAnalyticsConfiguration(const GetBucketAnalyticsConfigurationRequest& request) const
1535 {
1536 if (!request.BucketHasBeenSet())
1537 {
1538 AWS_LOGSTREAM_ERROR("GetBucketAnalyticsConfiguration", "Required field: Bucket, is not set");
1539 return GetBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1540 }
1541 if (!request.IdHasBeenSet())
1542 {
1543 AWS_LOGSTREAM_ERROR("GetBucketAnalyticsConfiguration", "Required field: Id, is not set");
1544 return GetBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1545 }
1546 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1547 if (!computeEndpointOutcome.IsSuccess())
1548 {
1549 return GetBucketAnalyticsConfigurationOutcome(computeEndpointOutcome.GetError());
1550 }
1551 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1552 Aws::StringStream ss;
1553 ss.str("?analytics");
1554 uri.SetQueryString(ss.str());
1555 return GetBucketAnalyticsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1556 }
1557
GetBucketAnalyticsConfigurationCallable(const GetBucketAnalyticsConfigurationRequest & request) const1558 GetBucketAnalyticsConfigurationOutcomeCallable S3CrtClient::GetBucketAnalyticsConfigurationCallable(const GetBucketAnalyticsConfigurationRequest& request) const
1559 {
1560 auto task = Aws::MakeShared< std::packaged_task< GetBucketAnalyticsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketAnalyticsConfiguration(request); } );
1561 auto packagedFunction = [task]() { (*task)(); };
1562 m_executor->Submit(packagedFunction);
1563 return task->get_future();
1564 }
1565
GetBucketAnalyticsConfigurationAsync(const GetBucketAnalyticsConfigurationRequest & request,const GetBucketAnalyticsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1566 void S3CrtClient::GetBucketAnalyticsConfigurationAsync(const GetBucketAnalyticsConfigurationRequest& request, const GetBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1567 {
1568 m_executor->Submit( [this, request, handler, context](){ this->GetBucketAnalyticsConfigurationAsyncHelper( request, handler, context ); } );
1569 }
1570
GetBucketAnalyticsConfigurationAsyncHelper(const GetBucketAnalyticsConfigurationRequest & request,const GetBucketAnalyticsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1571 void S3CrtClient::GetBucketAnalyticsConfigurationAsyncHelper(const GetBucketAnalyticsConfigurationRequest& request, const GetBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1572 {
1573 handler(this, request, GetBucketAnalyticsConfiguration(request), context);
1574 }
1575
GetBucketCors(const GetBucketCorsRequest & request) const1576 GetBucketCorsOutcome S3CrtClient::GetBucketCors(const GetBucketCorsRequest& request) const
1577 {
1578 if (!request.BucketHasBeenSet())
1579 {
1580 AWS_LOGSTREAM_ERROR("GetBucketCors", "Required field: Bucket, is not set");
1581 return GetBucketCorsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1582 }
1583 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1584 if (!computeEndpointOutcome.IsSuccess())
1585 {
1586 return GetBucketCorsOutcome(computeEndpointOutcome.GetError());
1587 }
1588 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1589 Aws::StringStream ss;
1590 ss.str("?cors");
1591 uri.SetQueryString(ss.str());
1592 return GetBucketCorsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1593 }
1594
GetBucketCorsCallable(const GetBucketCorsRequest & request) const1595 GetBucketCorsOutcomeCallable S3CrtClient::GetBucketCorsCallable(const GetBucketCorsRequest& request) const
1596 {
1597 auto task = Aws::MakeShared< std::packaged_task< GetBucketCorsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketCors(request); } );
1598 auto packagedFunction = [task]() { (*task)(); };
1599 m_executor->Submit(packagedFunction);
1600 return task->get_future();
1601 }
1602
GetBucketCorsAsync(const GetBucketCorsRequest & request,const GetBucketCorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1603 void S3CrtClient::GetBucketCorsAsync(const GetBucketCorsRequest& request, const GetBucketCorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1604 {
1605 m_executor->Submit( [this, request, handler, context](){ this->GetBucketCorsAsyncHelper( request, handler, context ); } );
1606 }
1607
GetBucketCorsAsyncHelper(const GetBucketCorsRequest & request,const GetBucketCorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1608 void S3CrtClient::GetBucketCorsAsyncHelper(const GetBucketCorsRequest& request, const GetBucketCorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1609 {
1610 handler(this, request, GetBucketCors(request), context);
1611 }
1612
GetBucketEncryption(const GetBucketEncryptionRequest & request) const1613 GetBucketEncryptionOutcome S3CrtClient::GetBucketEncryption(const GetBucketEncryptionRequest& request) const
1614 {
1615 if (!request.BucketHasBeenSet())
1616 {
1617 AWS_LOGSTREAM_ERROR("GetBucketEncryption", "Required field: Bucket, is not set");
1618 return GetBucketEncryptionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1619 }
1620 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1621 if (!computeEndpointOutcome.IsSuccess())
1622 {
1623 return GetBucketEncryptionOutcome(computeEndpointOutcome.GetError());
1624 }
1625 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1626 Aws::StringStream ss;
1627 ss.str("?encryption");
1628 uri.SetQueryString(ss.str());
1629 return GetBucketEncryptionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1630 }
1631
GetBucketEncryptionCallable(const GetBucketEncryptionRequest & request) const1632 GetBucketEncryptionOutcomeCallable S3CrtClient::GetBucketEncryptionCallable(const GetBucketEncryptionRequest& request) const
1633 {
1634 auto task = Aws::MakeShared< std::packaged_task< GetBucketEncryptionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketEncryption(request); } );
1635 auto packagedFunction = [task]() { (*task)(); };
1636 m_executor->Submit(packagedFunction);
1637 return task->get_future();
1638 }
1639
GetBucketEncryptionAsync(const GetBucketEncryptionRequest & request,const GetBucketEncryptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1640 void S3CrtClient::GetBucketEncryptionAsync(const GetBucketEncryptionRequest& request, const GetBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1641 {
1642 m_executor->Submit( [this, request, handler, context](){ this->GetBucketEncryptionAsyncHelper( request, handler, context ); } );
1643 }
1644
GetBucketEncryptionAsyncHelper(const GetBucketEncryptionRequest & request,const GetBucketEncryptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1645 void S3CrtClient::GetBucketEncryptionAsyncHelper(const GetBucketEncryptionRequest& request, const GetBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1646 {
1647 handler(this, request, GetBucketEncryption(request), context);
1648 }
1649
GetBucketIntelligentTieringConfiguration(const GetBucketIntelligentTieringConfigurationRequest & request) const1650 GetBucketIntelligentTieringConfigurationOutcome S3CrtClient::GetBucketIntelligentTieringConfiguration(const GetBucketIntelligentTieringConfigurationRequest& request) const
1651 {
1652 if (!request.BucketHasBeenSet())
1653 {
1654 AWS_LOGSTREAM_ERROR("GetBucketIntelligentTieringConfiguration", "Required field: Bucket, is not set");
1655 return GetBucketIntelligentTieringConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1656 }
1657 if (!request.IdHasBeenSet())
1658 {
1659 AWS_LOGSTREAM_ERROR("GetBucketIntelligentTieringConfiguration", "Required field: Id, is not set");
1660 return GetBucketIntelligentTieringConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1661 }
1662 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1663 if (!computeEndpointOutcome.IsSuccess())
1664 {
1665 return GetBucketIntelligentTieringConfigurationOutcome(computeEndpointOutcome.GetError());
1666 }
1667 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1668 Aws::StringStream ss;
1669 ss.str("?intelligent-tiering");
1670 uri.SetQueryString(ss.str());
1671 return GetBucketIntelligentTieringConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1672 }
1673
GetBucketIntelligentTieringConfigurationCallable(const GetBucketIntelligentTieringConfigurationRequest & request) const1674 GetBucketIntelligentTieringConfigurationOutcomeCallable S3CrtClient::GetBucketIntelligentTieringConfigurationCallable(const GetBucketIntelligentTieringConfigurationRequest& request) const
1675 {
1676 auto task = Aws::MakeShared< std::packaged_task< GetBucketIntelligentTieringConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketIntelligentTieringConfiguration(request); } );
1677 auto packagedFunction = [task]() { (*task)(); };
1678 m_executor->Submit(packagedFunction);
1679 return task->get_future();
1680 }
1681
GetBucketIntelligentTieringConfigurationAsync(const GetBucketIntelligentTieringConfigurationRequest & request,const GetBucketIntelligentTieringConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1682 void S3CrtClient::GetBucketIntelligentTieringConfigurationAsync(const GetBucketIntelligentTieringConfigurationRequest& request, const GetBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1683 {
1684 m_executor->Submit( [this, request, handler, context](){ this->GetBucketIntelligentTieringConfigurationAsyncHelper( request, handler, context ); } );
1685 }
1686
GetBucketIntelligentTieringConfigurationAsyncHelper(const GetBucketIntelligentTieringConfigurationRequest & request,const GetBucketIntelligentTieringConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1687 void S3CrtClient::GetBucketIntelligentTieringConfigurationAsyncHelper(const GetBucketIntelligentTieringConfigurationRequest& request, const GetBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1688 {
1689 handler(this, request, GetBucketIntelligentTieringConfiguration(request), context);
1690 }
1691
GetBucketInventoryConfiguration(const GetBucketInventoryConfigurationRequest & request) const1692 GetBucketInventoryConfigurationOutcome S3CrtClient::GetBucketInventoryConfiguration(const GetBucketInventoryConfigurationRequest& request) const
1693 {
1694 if (!request.BucketHasBeenSet())
1695 {
1696 AWS_LOGSTREAM_ERROR("GetBucketInventoryConfiguration", "Required field: Bucket, is not set");
1697 return GetBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1698 }
1699 if (!request.IdHasBeenSet())
1700 {
1701 AWS_LOGSTREAM_ERROR("GetBucketInventoryConfiguration", "Required field: Id, is not set");
1702 return GetBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1703 }
1704 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1705 if (!computeEndpointOutcome.IsSuccess())
1706 {
1707 return GetBucketInventoryConfigurationOutcome(computeEndpointOutcome.GetError());
1708 }
1709 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1710 Aws::StringStream ss;
1711 ss.str("?inventory");
1712 uri.SetQueryString(ss.str());
1713 return GetBucketInventoryConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1714 }
1715
GetBucketInventoryConfigurationCallable(const GetBucketInventoryConfigurationRequest & request) const1716 GetBucketInventoryConfigurationOutcomeCallable S3CrtClient::GetBucketInventoryConfigurationCallable(const GetBucketInventoryConfigurationRequest& request) const
1717 {
1718 auto task = Aws::MakeShared< std::packaged_task< GetBucketInventoryConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketInventoryConfiguration(request); } );
1719 auto packagedFunction = [task]() { (*task)(); };
1720 m_executor->Submit(packagedFunction);
1721 return task->get_future();
1722 }
1723
GetBucketInventoryConfigurationAsync(const GetBucketInventoryConfigurationRequest & request,const GetBucketInventoryConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1724 void S3CrtClient::GetBucketInventoryConfigurationAsync(const GetBucketInventoryConfigurationRequest& request, const GetBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1725 {
1726 m_executor->Submit( [this, request, handler, context](){ this->GetBucketInventoryConfigurationAsyncHelper( request, handler, context ); } );
1727 }
1728
GetBucketInventoryConfigurationAsyncHelper(const GetBucketInventoryConfigurationRequest & request,const GetBucketInventoryConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1729 void S3CrtClient::GetBucketInventoryConfigurationAsyncHelper(const GetBucketInventoryConfigurationRequest& request, const GetBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1730 {
1731 handler(this, request, GetBucketInventoryConfiguration(request), context);
1732 }
1733
GetBucketLifecycleConfiguration(const GetBucketLifecycleConfigurationRequest & request) const1734 GetBucketLifecycleConfigurationOutcome S3CrtClient::GetBucketLifecycleConfiguration(const GetBucketLifecycleConfigurationRequest& request) const
1735 {
1736 if (!request.BucketHasBeenSet())
1737 {
1738 AWS_LOGSTREAM_ERROR("GetBucketLifecycleConfiguration", "Required field: Bucket, is not set");
1739 return GetBucketLifecycleConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1740 }
1741 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1742 if (!computeEndpointOutcome.IsSuccess())
1743 {
1744 return GetBucketLifecycleConfigurationOutcome(computeEndpointOutcome.GetError());
1745 }
1746 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1747 Aws::StringStream ss;
1748 ss.str("?lifecycle");
1749 uri.SetQueryString(ss.str());
1750 return GetBucketLifecycleConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1751 }
1752
GetBucketLifecycleConfigurationCallable(const GetBucketLifecycleConfigurationRequest & request) const1753 GetBucketLifecycleConfigurationOutcomeCallable S3CrtClient::GetBucketLifecycleConfigurationCallable(const GetBucketLifecycleConfigurationRequest& request) const
1754 {
1755 auto task = Aws::MakeShared< std::packaged_task< GetBucketLifecycleConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketLifecycleConfiguration(request); } );
1756 auto packagedFunction = [task]() { (*task)(); };
1757 m_executor->Submit(packagedFunction);
1758 return task->get_future();
1759 }
1760
GetBucketLifecycleConfigurationAsync(const GetBucketLifecycleConfigurationRequest & request,const GetBucketLifecycleConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1761 void S3CrtClient::GetBucketLifecycleConfigurationAsync(const GetBucketLifecycleConfigurationRequest& request, const GetBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1762 {
1763 m_executor->Submit( [this, request, handler, context](){ this->GetBucketLifecycleConfigurationAsyncHelper( request, handler, context ); } );
1764 }
1765
GetBucketLifecycleConfigurationAsyncHelper(const GetBucketLifecycleConfigurationRequest & request,const GetBucketLifecycleConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1766 void S3CrtClient::GetBucketLifecycleConfigurationAsyncHelper(const GetBucketLifecycleConfigurationRequest& request, const GetBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1767 {
1768 handler(this, request, GetBucketLifecycleConfiguration(request), context);
1769 }
1770
GetBucketLocation(const GetBucketLocationRequest & request) const1771 GetBucketLocationOutcome S3CrtClient::GetBucketLocation(const GetBucketLocationRequest& request) const
1772 {
1773 if (!request.BucketHasBeenSet())
1774 {
1775 AWS_LOGSTREAM_ERROR("GetBucketLocation", "Required field: Bucket, is not set");
1776 return GetBucketLocationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1777 }
1778 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1779 if (!computeEndpointOutcome.IsSuccess())
1780 {
1781 return GetBucketLocationOutcome(computeEndpointOutcome.GetError());
1782 }
1783 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1784 Aws::StringStream ss;
1785 ss.str("?location");
1786 uri.SetQueryString(ss.str());
1787 return GetBucketLocationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1788 }
1789
GetBucketLocationCallable(const GetBucketLocationRequest & request) const1790 GetBucketLocationOutcomeCallable S3CrtClient::GetBucketLocationCallable(const GetBucketLocationRequest& request) const
1791 {
1792 auto task = Aws::MakeShared< std::packaged_task< GetBucketLocationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketLocation(request); } );
1793 auto packagedFunction = [task]() { (*task)(); };
1794 m_executor->Submit(packagedFunction);
1795 return task->get_future();
1796 }
1797
GetBucketLocationAsync(const GetBucketLocationRequest & request,const GetBucketLocationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1798 void S3CrtClient::GetBucketLocationAsync(const GetBucketLocationRequest& request, const GetBucketLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1799 {
1800 m_executor->Submit( [this, request, handler, context](){ this->GetBucketLocationAsyncHelper( request, handler, context ); } );
1801 }
1802
GetBucketLocationAsyncHelper(const GetBucketLocationRequest & request,const GetBucketLocationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1803 void S3CrtClient::GetBucketLocationAsyncHelper(const GetBucketLocationRequest& request, const GetBucketLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1804 {
1805 handler(this, request, GetBucketLocation(request), context);
1806 }
1807
GetBucketLogging(const GetBucketLoggingRequest & request) const1808 GetBucketLoggingOutcome S3CrtClient::GetBucketLogging(const GetBucketLoggingRequest& request) const
1809 {
1810 if (!request.BucketHasBeenSet())
1811 {
1812 AWS_LOGSTREAM_ERROR("GetBucketLogging", "Required field: Bucket, is not set");
1813 return GetBucketLoggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1814 }
1815 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1816 if (!computeEndpointOutcome.IsSuccess())
1817 {
1818 return GetBucketLoggingOutcome(computeEndpointOutcome.GetError());
1819 }
1820 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1821 Aws::StringStream ss;
1822 ss.str("?logging");
1823 uri.SetQueryString(ss.str());
1824 return GetBucketLoggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1825 }
1826
GetBucketLoggingCallable(const GetBucketLoggingRequest & request) const1827 GetBucketLoggingOutcomeCallable S3CrtClient::GetBucketLoggingCallable(const GetBucketLoggingRequest& request) const
1828 {
1829 auto task = Aws::MakeShared< std::packaged_task< GetBucketLoggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketLogging(request); } );
1830 auto packagedFunction = [task]() { (*task)(); };
1831 m_executor->Submit(packagedFunction);
1832 return task->get_future();
1833 }
1834
GetBucketLoggingAsync(const GetBucketLoggingRequest & request,const GetBucketLoggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1835 void S3CrtClient::GetBucketLoggingAsync(const GetBucketLoggingRequest& request, const GetBucketLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1836 {
1837 m_executor->Submit( [this, request, handler, context](){ this->GetBucketLoggingAsyncHelper( request, handler, context ); } );
1838 }
1839
GetBucketLoggingAsyncHelper(const GetBucketLoggingRequest & request,const GetBucketLoggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1840 void S3CrtClient::GetBucketLoggingAsyncHelper(const GetBucketLoggingRequest& request, const GetBucketLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1841 {
1842 handler(this, request, GetBucketLogging(request), context);
1843 }
1844
GetBucketMetricsConfiguration(const GetBucketMetricsConfigurationRequest & request) const1845 GetBucketMetricsConfigurationOutcome S3CrtClient::GetBucketMetricsConfiguration(const GetBucketMetricsConfigurationRequest& request) const
1846 {
1847 if (!request.BucketHasBeenSet())
1848 {
1849 AWS_LOGSTREAM_ERROR("GetBucketMetricsConfiguration", "Required field: Bucket, is not set");
1850 return GetBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1851 }
1852 if (!request.IdHasBeenSet())
1853 {
1854 AWS_LOGSTREAM_ERROR("GetBucketMetricsConfiguration", "Required field: Id, is not set");
1855 return GetBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1856 }
1857 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1858 if (!computeEndpointOutcome.IsSuccess())
1859 {
1860 return GetBucketMetricsConfigurationOutcome(computeEndpointOutcome.GetError());
1861 }
1862 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1863 Aws::StringStream ss;
1864 ss.str("?metrics");
1865 uri.SetQueryString(ss.str());
1866 return GetBucketMetricsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1867 }
1868
GetBucketMetricsConfigurationCallable(const GetBucketMetricsConfigurationRequest & request) const1869 GetBucketMetricsConfigurationOutcomeCallable S3CrtClient::GetBucketMetricsConfigurationCallable(const GetBucketMetricsConfigurationRequest& request) const
1870 {
1871 auto task = Aws::MakeShared< std::packaged_task< GetBucketMetricsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketMetricsConfiguration(request); } );
1872 auto packagedFunction = [task]() { (*task)(); };
1873 m_executor->Submit(packagedFunction);
1874 return task->get_future();
1875 }
1876
GetBucketMetricsConfigurationAsync(const GetBucketMetricsConfigurationRequest & request,const GetBucketMetricsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1877 void S3CrtClient::GetBucketMetricsConfigurationAsync(const GetBucketMetricsConfigurationRequest& request, const GetBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1878 {
1879 m_executor->Submit( [this, request, handler, context](){ this->GetBucketMetricsConfigurationAsyncHelper( request, handler, context ); } );
1880 }
1881
GetBucketMetricsConfigurationAsyncHelper(const GetBucketMetricsConfigurationRequest & request,const GetBucketMetricsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1882 void S3CrtClient::GetBucketMetricsConfigurationAsyncHelper(const GetBucketMetricsConfigurationRequest& request, const GetBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1883 {
1884 handler(this, request, GetBucketMetricsConfiguration(request), context);
1885 }
1886
GetBucketNotificationConfiguration(const GetBucketNotificationConfigurationRequest & request) const1887 GetBucketNotificationConfigurationOutcome S3CrtClient::GetBucketNotificationConfiguration(const GetBucketNotificationConfigurationRequest& request) const
1888 {
1889 if (!request.BucketHasBeenSet())
1890 {
1891 AWS_LOGSTREAM_ERROR("GetBucketNotificationConfiguration", "Required field: Bucket, is not set");
1892 return GetBucketNotificationConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1893 }
1894 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1895 if (!computeEndpointOutcome.IsSuccess())
1896 {
1897 return GetBucketNotificationConfigurationOutcome(computeEndpointOutcome.GetError());
1898 }
1899 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1900 Aws::StringStream ss;
1901 ss.str("?notification");
1902 uri.SetQueryString(ss.str());
1903 return GetBucketNotificationConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1904 }
1905
GetBucketNotificationConfigurationCallable(const GetBucketNotificationConfigurationRequest & request) const1906 GetBucketNotificationConfigurationOutcomeCallable S3CrtClient::GetBucketNotificationConfigurationCallable(const GetBucketNotificationConfigurationRequest& request) const
1907 {
1908 auto task = Aws::MakeShared< std::packaged_task< GetBucketNotificationConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketNotificationConfiguration(request); } );
1909 auto packagedFunction = [task]() { (*task)(); };
1910 m_executor->Submit(packagedFunction);
1911 return task->get_future();
1912 }
1913
GetBucketNotificationConfigurationAsync(const GetBucketNotificationConfigurationRequest & request,const GetBucketNotificationConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1914 void S3CrtClient::GetBucketNotificationConfigurationAsync(const GetBucketNotificationConfigurationRequest& request, const GetBucketNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1915 {
1916 m_executor->Submit( [this, request, handler, context](){ this->GetBucketNotificationConfigurationAsyncHelper( request, handler, context ); } );
1917 }
1918
GetBucketNotificationConfigurationAsyncHelper(const GetBucketNotificationConfigurationRequest & request,const GetBucketNotificationConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1919 void S3CrtClient::GetBucketNotificationConfigurationAsyncHelper(const GetBucketNotificationConfigurationRequest& request, const GetBucketNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1920 {
1921 handler(this, request, GetBucketNotificationConfiguration(request), context);
1922 }
1923
GetBucketOwnershipControls(const GetBucketOwnershipControlsRequest & request) const1924 GetBucketOwnershipControlsOutcome S3CrtClient::GetBucketOwnershipControls(const GetBucketOwnershipControlsRequest& request) const
1925 {
1926 if (!request.BucketHasBeenSet())
1927 {
1928 AWS_LOGSTREAM_ERROR("GetBucketOwnershipControls", "Required field: Bucket, is not set");
1929 return GetBucketOwnershipControlsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1930 }
1931 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1932 if (!computeEndpointOutcome.IsSuccess())
1933 {
1934 return GetBucketOwnershipControlsOutcome(computeEndpointOutcome.GetError());
1935 }
1936 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1937 Aws::StringStream ss;
1938 ss.str("?ownershipControls");
1939 uri.SetQueryString(ss.str());
1940 return GetBucketOwnershipControlsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1941 }
1942
GetBucketOwnershipControlsCallable(const GetBucketOwnershipControlsRequest & request) const1943 GetBucketOwnershipControlsOutcomeCallable S3CrtClient::GetBucketOwnershipControlsCallable(const GetBucketOwnershipControlsRequest& request) const
1944 {
1945 auto task = Aws::MakeShared< std::packaged_task< GetBucketOwnershipControlsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketOwnershipControls(request); } );
1946 auto packagedFunction = [task]() { (*task)(); };
1947 m_executor->Submit(packagedFunction);
1948 return task->get_future();
1949 }
1950
GetBucketOwnershipControlsAsync(const GetBucketOwnershipControlsRequest & request,const GetBucketOwnershipControlsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1951 void S3CrtClient::GetBucketOwnershipControlsAsync(const GetBucketOwnershipControlsRequest& request, const GetBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1952 {
1953 m_executor->Submit( [this, request, handler, context](){ this->GetBucketOwnershipControlsAsyncHelper( request, handler, context ); } );
1954 }
1955
GetBucketOwnershipControlsAsyncHelper(const GetBucketOwnershipControlsRequest & request,const GetBucketOwnershipControlsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1956 void S3CrtClient::GetBucketOwnershipControlsAsyncHelper(const GetBucketOwnershipControlsRequest& request, const GetBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1957 {
1958 handler(this, request, GetBucketOwnershipControls(request), context);
1959 }
1960
GetBucketPolicy(const GetBucketPolicyRequest & request) const1961 GetBucketPolicyOutcome S3CrtClient::GetBucketPolicy(const GetBucketPolicyRequest& request) const
1962 {
1963 if (!request.BucketHasBeenSet())
1964 {
1965 AWS_LOGSTREAM_ERROR("GetBucketPolicy", "Required field: Bucket, is not set");
1966 return GetBucketPolicyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
1967 }
1968 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
1969 if (!computeEndpointOutcome.IsSuccess())
1970 {
1971 return GetBucketPolicyOutcome(computeEndpointOutcome.GetError());
1972 }
1973 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
1974 Aws::StringStream ss;
1975 ss.str("?policy");
1976 uri.SetQueryString(ss.str());
1977 return GetBucketPolicyOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
1978 }
1979
GetBucketPolicyCallable(const GetBucketPolicyRequest & request) const1980 GetBucketPolicyOutcomeCallable S3CrtClient::GetBucketPolicyCallable(const GetBucketPolicyRequest& request) const
1981 {
1982 auto task = Aws::MakeShared< std::packaged_task< GetBucketPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketPolicy(request); } );
1983 auto packagedFunction = [task]() { (*task)(); };
1984 m_executor->Submit(packagedFunction);
1985 return task->get_future();
1986 }
1987
GetBucketPolicyAsync(const GetBucketPolicyRequest & request,const GetBucketPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1988 void S3CrtClient::GetBucketPolicyAsync(const GetBucketPolicyRequest& request, const GetBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1989 {
1990 m_executor->Submit( [this, request, handler, context](){ this->GetBucketPolicyAsyncHelper( request, handler, context ); } );
1991 }
1992
GetBucketPolicyAsyncHelper(const GetBucketPolicyRequest & request,const GetBucketPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1993 void S3CrtClient::GetBucketPolicyAsyncHelper(const GetBucketPolicyRequest& request, const GetBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1994 {
1995 handler(this, request, GetBucketPolicy(request), context);
1996 }
1997
GetBucketPolicyStatus(const GetBucketPolicyStatusRequest & request) const1998 GetBucketPolicyStatusOutcome S3CrtClient::GetBucketPolicyStatus(const GetBucketPolicyStatusRequest& request) const
1999 {
2000 if (!request.BucketHasBeenSet())
2001 {
2002 AWS_LOGSTREAM_ERROR("GetBucketPolicyStatus", "Required field: Bucket, is not set");
2003 return GetBucketPolicyStatusOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2004 }
2005 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2006 if (!computeEndpointOutcome.IsSuccess())
2007 {
2008 return GetBucketPolicyStatusOutcome(computeEndpointOutcome.GetError());
2009 }
2010 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2011 Aws::StringStream ss;
2012 ss.str("?policyStatus");
2013 uri.SetQueryString(ss.str());
2014 return GetBucketPolicyStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2015 }
2016
GetBucketPolicyStatusCallable(const GetBucketPolicyStatusRequest & request) const2017 GetBucketPolicyStatusOutcomeCallable S3CrtClient::GetBucketPolicyStatusCallable(const GetBucketPolicyStatusRequest& request) const
2018 {
2019 auto task = Aws::MakeShared< std::packaged_task< GetBucketPolicyStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketPolicyStatus(request); } );
2020 auto packagedFunction = [task]() { (*task)(); };
2021 m_executor->Submit(packagedFunction);
2022 return task->get_future();
2023 }
2024
GetBucketPolicyStatusAsync(const GetBucketPolicyStatusRequest & request,const GetBucketPolicyStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2025 void S3CrtClient::GetBucketPolicyStatusAsync(const GetBucketPolicyStatusRequest& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2026 {
2027 m_executor->Submit( [this, request, handler, context](){ this->GetBucketPolicyStatusAsyncHelper( request, handler, context ); } );
2028 }
2029
GetBucketPolicyStatusAsyncHelper(const GetBucketPolicyStatusRequest & request,const GetBucketPolicyStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2030 void S3CrtClient::GetBucketPolicyStatusAsyncHelper(const GetBucketPolicyStatusRequest& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2031 {
2032 handler(this, request, GetBucketPolicyStatus(request), context);
2033 }
2034
GetBucketReplication(const GetBucketReplicationRequest & request) const2035 GetBucketReplicationOutcome S3CrtClient::GetBucketReplication(const GetBucketReplicationRequest& request) const
2036 {
2037 if (!request.BucketHasBeenSet())
2038 {
2039 AWS_LOGSTREAM_ERROR("GetBucketReplication", "Required field: Bucket, is not set");
2040 return GetBucketReplicationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2041 }
2042 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2043 if (!computeEndpointOutcome.IsSuccess())
2044 {
2045 return GetBucketReplicationOutcome(computeEndpointOutcome.GetError());
2046 }
2047 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2048 Aws::StringStream ss;
2049 ss.str("?replication");
2050 uri.SetQueryString(ss.str());
2051 return GetBucketReplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2052 }
2053
GetBucketReplicationCallable(const GetBucketReplicationRequest & request) const2054 GetBucketReplicationOutcomeCallable S3CrtClient::GetBucketReplicationCallable(const GetBucketReplicationRequest& request) const
2055 {
2056 auto task = Aws::MakeShared< std::packaged_task< GetBucketReplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketReplication(request); } );
2057 auto packagedFunction = [task]() { (*task)(); };
2058 m_executor->Submit(packagedFunction);
2059 return task->get_future();
2060 }
2061
GetBucketReplicationAsync(const GetBucketReplicationRequest & request,const GetBucketReplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2062 void S3CrtClient::GetBucketReplicationAsync(const GetBucketReplicationRequest& request, const GetBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2063 {
2064 m_executor->Submit( [this, request, handler, context](){ this->GetBucketReplicationAsyncHelper( request, handler, context ); } );
2065 }
2066
GetBucketReplicationAsyncHelper(const GetBucketReplicationRequest & request,const GetBucketReplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2067 void S3CrtClient::GetBucketReplicationAsyncHelper(const GetBucketReplicationRequest& request, const GetBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2068 {
2069 handler(this, request, GetBucketReplication(request), context);
2070 }
2071
GetBucketRequestPayment(const GetBucketRequestPaymentRequest & request) const2072 GetBucketRequestPaymentOutcome S3CrtClient::GetBucketRequestPayment(const GetBucketRequestPaymentRequest& request) const
2073 {
2074 if (!request.BucketHasBeenSet())
2075 {
2076 AWS_LOGSTREAM_ERROR("GetBucketRequestPayment", "Required field: Bucket, is not set");
2077 return GetBucketRequestPaymentOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2078 }
2079 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2080 if (!computeEndpointOutcome.IsSuccess())
2081 {
2082 return GetBucketRequestPaymentOutcome(computeEndpointOutcome.GetError());
2083 }
2084 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2085 Aws::StringStream ss;
2086 ss.str("?requestPayment");
2087 uri.SetQueryString(ss.str());
2088 return GetBucketRequestPaymentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2089 }
2090
GetBucketRequestPaymentCallable(const GetBucketRequestPaymentRequest & request) const2091 GetBucketRequestPaymentOutcomeCallable S3CrtClient::GetBucketRequestPaymentCallable(const GetBucketRequestPaymentRequest& request) const
2092 {
2093 auto task = Aws::MakeShared< std::packaged_task< GetBucketRequestPaymentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketRequestPayment(request); } );
2094 auto packagedFunction = [task]() { (*task)(); };
2095 m_executor->Submit(packagedFunction);
2096 return task->get_future();
2097 }
2098
GetBucketRequestPaymentAsync(const GetBucketRequestPaymentRequest & request,const GetBucketRequestPaymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2099 void S3CrtClient::GetBucketRequestPaymentAsync(const GetBucketRequestPaymentRequest& request, const GetBucketRequestPaymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2100 {
2101 m_executor->Submit( [this, request, handler, context](){ this->GetBucketRequestPaymentAsyncHelper( request, handler, context ); } );
2102 }
2103
GetBucketRequestPaymentAsyncHelper(const GetBucketRequestPaymentRequest & request,const GetBucketRequestPaymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2104 void S3CrtClient::GetBucketRequestPaymentAsyncHelper(const GetBucketRequestPaymentRequest& request, const GetBucketRequestPaymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2105 {
2106 handler(this, request, GetBucketRequestPayment(request), context);
2107 }
2108
GetBucketTagging(const GetBucketTaggingRequest & request) const2109 GetBucketTaggingOutcome S3CrtClient::GetBucketTagging(const GetBucketTaggingRequest& request) const
2110 {
2111 if (!request.BucketHasBeenSet())
2112 {
2113 AWS_LOGSTREAM_ERROR("GetBucketTagging", "Required field: Bucket, is not set");
2114 return GetBucketTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2115 }
2116 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2117 if (!computeEndpointOutcome.IsSuccess())
2118 {
2119 return GetBucketTaggingOutcome(computeEndpointOutcome.GetError());
2120 }
2121 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2122 Aws::StringStream ss;
2123 ss.str("?tagging");
2124 uri.SetQueryString(ss.str());
2125 return GetBucketTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2126 }
2127
GetBucketTaggingCallable(const GetBucketTaggingRequest & request) const2128 GetBucketTaggingOutcomeCallable S3CrtClient::GetBucketTaggingCallable(const GetBucketTaggingRequest& request) const
2129 {
2130 auto task = Aws::MakeShared< std::packaged_task< GetBucketTaggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketTagging(request); } );
2131 auto packagedFunction = [task]() { (*task)(); };
2132 m_executor->Submit(packagedFunction);
2133 return task->get_future();
2134 }
2135
GetBucketTaggingAsync(const GetBucketTaggingRequest & request,const GetBucketTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2136 void S3CrtClient::GetBucketTaggingAsync(const GetBucketTaggingRequest& request, const GetBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2137 {
2138 m_executor->Submit( [this, request, handler, context](){ this->GetBucketTaggingAsyncHelper( request, handler, context ); } );
2139 }
2140
GetBucketTaggingAsyncHelper(const GetBucketTaggingRequest & request,const GetBucketTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2141 void S3CrtClient::GetBucketTaggingAsyncHelper(const GetBucketTaggingRequest& request, const GetBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2142 {
2143 handler(this, request, GetBucketTagging(request), context);
2144 }
2145
GetBucketVersioning(const GetBucketVersioningRequest & request) const2146 GetBucketVersioningOutcome S3CrtClient::GetBucketVersioning(const GetBucketVersioningRequest& request) const
2147 {
2148 if (!request.BucketHasBeenSet())
2149 {
2150 AWS_LOGSTREAM_ERROR("GetBucketVersioning", "Required field: Bucket, is not set");
2151 return GetBucketVersioningOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2152 }
2153 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2154 if (!computeEndpointOutcome.IsSuccess())
2155 {
2156 return GetBucketVersioningOutcome(computeEndpointOutcome.GetError());
2157 }
2158 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2159 Aws::StringStream ss;
2160 ss.str("?versioning");
2161 uri.SetQueryString(ss.str());
2162 return GetBucketVersioningOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2163 }
2164
GetBucketVersioningCallable(const GetBucketVersioningRequest & request) const2165 GetBucketVersioningOutcomeCallable S3CrtClient::GetBucketVersioningCallable(const GetBucketVersioningRequest& request) const
2166 {
2167 auto task = Aws::MakeShared< std::packaged_task< GetBucketVersioningOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketVersioning(request); } );
2168 auto packagedFunction = [task]() { (*task)(); };
2169 m_executor->Submit(packagedFunction);
2170 return task->get_future();
2171 }
2172
GetBucketVersioningAsync(const GetBucketVersioningRequest & request,const GetBucketVersioningResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2173 void S3CrtClient::GetBucketVersioningAsync(const GetBucketVersioningRequest& request, const GetBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2174 {
2175 m_executor->Submit( [this, request, handler, context](){ this->GetBucketVersioningAsyncHelper( request, handler, context ); } );
2176 }
2177
GetBucketVersioningAsyncHelper(const GetBucketVersioningRequest & request,const GetBucketVersioningResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2178 void S3CrtClient::GetBucketVersioningAsyncHelper(const GetBucketVersioningRequest& request, const GetBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2179 {
2180 handler(this, request, GetBucketVersioning(request), context);
2181 }
2182
GetBucketWebsite(const GetBucketWebsiteRequest & request) const2183 GetBucketWebsiteOutcome S3CrtClient::GetBucketWebsite(const GetBucketWebsiteRequest& request) const
2184 {
2185 if (!request.BucketHasBeenSet())
2186 {
2187 AWS_LOGSTREAM_ERROR("GetBucketWebsite", "Required field: Bucket, is not set");
2188 return GetBucketWebsiteOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2189 }
2190 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2191 if (!computeEndpointOutcome.IsSuccess())
2192 {
2193 return GetBucketWebsiteOutcome(computeEndpointOutcome.GetError());
2194 }
2195 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2196 Aws::StringStream ss;
2197 ss.str("?website");
2198 uri.SetQueryString(ss.str());
2199 return GetBucketWebsiteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2200 }
2201
GetBucketWebsiteCallable(const GetBucketWebsiteRequest & request) const2202 GetBucketWebsiteOutcomeCallable S3CrtClient::GetBucketWebsiteCallable(const GetBucketWebsiteRequest& request) const
2203 {
2204 auto task = Aws::MakeShared< std::packaged_task< GetBucketWebsiteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketWebsite(request); } );
2205 auto packagedFunction = [task]() { (*task)(); };
2206 m_executor->Submit(packagedFunction);
2207 return task->get_future();
2208 }
2209
GetBucketWebsiteAsync(const GetBucketWebsiteRequest & request,const GetBucketWebsiteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2210 void S3CrtClient::GetBucketWebsiteAsync(const GetBucketWebsiteRequest& request, const GetBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2211 {
2212 m_executor->Submit( [this, request, handler, context](){ this->GetBucketWebsiteAsyncHelper( request, handler, context ); } );
2213 }
2214
GetBucketWebsiteAsyncHelper(const GetBucketWebsiteRequest & request,const GetBucketWebsiteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2215 void S3CrtClient::GetBucketWebsiteAsyncHelper(const GetBucketWebsiteRequest& request, const GetBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2216 {
2217 handler(this, request, GetBucketWebsite(request), context);
2218 }
2219
GetObjectAcl(const GetObjectAclRequest & request) const2220 GetObjectAclOutcome S3CrtClient::GetObjectAcl(const GetObjectAclRequest& request) const
2221 {
2222 if (!request.BucketHasBeenSet())
2223 {
2224 AWS_LOGSTREAM_ERROR("GetObjectAcl", "Required field: Bucket, is not set");
2225 return GetObjectAclOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2226 }
2227 if (!request.KeyHasBeenSet())
2228 {
2229 AWS_LOGSTREAM_ERROR("GetObjectAcl", "Required field: Key, is not set");
2230 return GetObjectAclOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2231 }
2232 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2233 if (!computeEndpointOutcome.IsSuccess())
2234 {
2235 return GetObjectAclOutcome(computeEndpointOutcome.GetError());
2236 }
2237 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2238 Aws::StringStream ss;
2239 uri.AddPathSegments(request.GetKey());
2240 ss.str("?acl");
2241 uri.SetQueryString(ss.str());
2242 return GetObjectAclOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2243 }
2244
GetObjectAclCallable(const GetObjectAclRequest & request) const2245 GetObjectAclOutcomeCallable S3CrtClient::GetObjectAclCallable(const GetObjectAclRequest& request) const
2246 {
2247 auto task = Aws::MakeShared< std::packaged_task< GetObjectAclOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectAcl(request); } );
2248 auto packagedFunction = [task]() { (*task)(); };
2249 m_executor->Submit(packagedFunction);
2250 return task->get_future();
2251 }
2252
GetObjectAclAsync(const GetObjectAclRequest & request,const GetObjectAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2253 void S3CrtClient::GetObjectAclAsync(const GetObjectAclRequest& request, const GetObjectAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2254 {
2255 m_executor->Submit( [this, request, handler, context](){ this->GetObjectAclAsyncHelper( request, handler, context ); } );
2256 }
2257
GetObjectAclAsyncHelper(const GetObjectAclRequest & request,const GetObjectAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2258 void S3CrtClient::GetObjectAclAsyncHelper(const GetObjectAclRequest& request, const GetObjectAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2259 {
2260 handler(this, request, GetObjectAcl(request), context);
2261 }
2262
GetObjectLegalHold(const GetObjectLegalHoldRequest & request) const2263 GetObjectLegalHoldOutcome S3CrtClient::GetObjectLegalHold(const GetObjectLegalHoldRequest& request) const
2264 {
2265 if (!request.BucketHasBeenSet())
2266 {
2267 AWS_LOGSTREAM_ERROR("GetObjectLegalHold", "Required field: Bucket, is not set");
2268 return GetObjectLegalHoldOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2269 }
2270 if (!request.KeyHasBeenSet())
2271 {
2272 AWS_LOGSTREAM_ERROR("GetObjectLegalHold", "Required field: Key, is not set");
2273 return GetObjectLegalHoldOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2274 }
2275 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2276 if (!computeEndpointOutcome.IsSuccess())
2277 {
2278 return GetObjectLegalHoldOutcome(computeEndpointOutcome.GetError());
2279 }
2280 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2281 Aws::StringStream ss;
2282 uri.AddPathSegments(request.GetKey());
2283 ss.str("?legal-hold");
2284 uri.SetQueryString(ss.str());
2285 return GetObjectLegalHoldOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2286 }
2287
GetObjectLegalHoldCallable(const GetObjectLegalHoldRequest & request) const2288 GetObjectLegalHoldOutcomeCallable S3CrtClient::GetObjectLegalHoldCallable(const GetObjectLegalHoldRequest& request) const
2289 {
2290 auto task = Aws::MakeShared< std::packaged_task< GetObjectLegalHoldOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectLegalHold(request); } );
2291 auto packagedFunction = [task]() { (*task)(); };
2292 m_executor->Submit(packagedFunction);
2293 return task->get_future();
2294 }
2295
GetObjectLegalHoldAsync(const GetObjectLegalHoldRequest & request,const GetObjectLegalHoldResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2296 void S3CrtClient::GetObjectLegalHoldAsync(const GetObjectLegalHoldRequest& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2297 {
2298 m_executor->Submit( [this, request, handler, context](){ this->GetObjectLegalHoldAsyncHelper( request, handler, context ); } );
2299 }
2300
GetObjectLegalHoldAsyncHelper(const GetObjectLegalHoldRequest & request,const GetObjectLegalHoldResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2301 void S3CrtClient::GetObjectLegalHoldAsyncHelper(const GetObjectLegalHoldRequest& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2302 {
2303 handler(this, request, GetObjectLegalHold(request), context);
2304 }
2305
GetObjectLockConfiguration(const GetObjectLockConfigurationRequest & request) const2306 GetObjectLockConfigurationOutcome S3CrtClient::GetObjectLockConfiguration(const GetObjectLockConfigurationRequest& request) const
2307 {
2308 if (!request.BucketHasBeenSet())
2309 {
2310 AWS_LOGSTREAM_ERROR("GetObjectLockConfiguration", "Required field: Bucket, is not set");
2311 return GetObjectLockConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2312 }
2313 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2314 if (!computeEndpointOutcome.IsSuccess())
2315 {
2316 return GetObjectLockConfigurationOutcome(computeEndpointOutcome.GetError());
2317 }
2318 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2319 Aws::StringStream ss;
2320 ss.str("?object-lock");
2321 uri.SetQueryString(ss.str());
2322 return GetObjectLockConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2323 }
2324
GetObjectLockConfigurationCallable(const GetObjectLockConfigurationRequest & request) const2325 GetObjectLockConfigurationOutcomeCallable S3CrtClient::GetObjectLockConfigurationCallable(const GetObjectLockConfigurationRequest& request) const
2326 {
2327 auto task = Aws::MakeShared< std::packaged_task< GetObjectLockConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectLockConfiguration(request); } );
2328 auto packagedFunction = [task]() { (*task)(); };
2329 m_executor->Submit(packagedFunction);
2330 return task->get_future();
2331 }
2332
GetObjectLockConfigurationAsync(const GetObjectLockConfigurationRequest & request,const GetObjectLockConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2333 void S3CrtClient::GetObjectLockConfigurationAsync(const GetObjectLockConfigurationRequest& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2334 {
2335 m_executor->Submit( [this, request, handler, context](){ this->GetObjectLockConfigurationAsyncHelper( request, handler, context ); } );
2336 }
2337
GetObjectLockConfigurationAsyncHelper(const GetObjectLockConfigurationRequest & request,const GetObjectLockConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2338 void S3CrtClient::GetObjectLockConfigurationAsyncHelper(const GetObjectLockConfigurationRequest& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2339 {
2340 handler(this, request, GetObjectLockConfiguration(request), context);
2341 }
2342
GetObjectRetention(const GetObjectRetentionRequest & request) const2343 GetObjectRetentionOutcome S3CrtClient::GetObjectRetention(const GetObjectRetentionRequest& request) const
2344 {
2345 if (!request.BucketHasBeenSet())
2346 {
2347 AWS_LOGSTREAM_ERROR("GetObjectRetention", "Required field: Bucket, is not set");
2348 return GetObjectRetentionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2349 }
2350 if (!request.KeyHasBeenSet())
2351 {
2352 AWS_LOGSTREAM_ERROR("GetObjectRetention", "Required field: Key, is not set");
2353 return GetObjectRetentionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2354 }
2355 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2356 if (!computeEndpointOutcome.IsSuccess())
2357 {
2358 return GetObjectRetentionOutcome(computeEndpointOutcome.GetError());
2359 }
2360 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2361 Aws::StringStream ss;
2362 uri.AddPathSegments(request.GetKey());
2363 ss.str("?retention");
2364 uri.SetQueryString(ss.str());
2365 return GetObjectRetentionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2366 }
2367
GetObjectRetentionCallable(const GetObjectRetentionRequest & request) const2368 GetObjectRetentionOutcomeCallable S3CrtClient::GetObjectRetentionCallable(const GetObjectRetentionRequest& request) const
2369 {
2370 auto task = Aws::MakeShared< std::packaged_task< GetObjectRetentionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectRetention(request); } );
2371 auto packagedFunction = [task]() { (*task)(); };
2372 m_executor->Submit(packagedFunction);
2373 return task->get_future();
2374 }
2375
GetObjectRetentionAsync(const GetObjectRetentionRequest & request,const GetObjectRetentionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2376 void S3CrtClient::GetObjectRetentionAsync(const GetObjectRetentionRequest& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2377 {
2378 m_executor->Submit( [this, request, handler, context](){ this->GetObjectRetentionAsyncHelper( request, handler, context ); } );
2379 }
2380
GetObjectRetentionAsyncHelper(const GetObjectRetentionRequest & request,const GetObjectRetentionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2381 void S3CrtClient::GetObjectRetentionAsyncHelper(const GetObjectRetentionRequest& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2382 {
2383 handler(this, request, GetObjectRetention(request), context);
2384 }
2385
GetObjectTagging(const GetObjectTaggingRequest & request) const2386 GetObjectTaggingOutcome S3CrtClient::GetObjectTagging(const GetObjectTaggingRequest& request) const
2387 {
2388 if (!request.BucketHasBeenSet())
2389 {
2390 AWS_LOGSTREAM_ERROR("GetObjectTagging", "Required field: Bucket, is not set");
2391 return GetObjectTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2392 }
2393 if (!request.KeyHasBeenSet())
2394 {
2395 AWS_LOGSTREAM_ERROR("GetObjectTagging", "Required field: Key, is not set");
2396 return GetObjectTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2397 }
2398 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2399 if (!computeEndpointOutcome.IsSuccess())
2400 {
2401 return GetObjectTaggingOutcome(computeEndpointOutcome.GetError());
2402 }
2403 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2404 Aws::StringStream ss;
2405 uri.AddPathSegments(request.GetKey());
2406 ss.str("?tagging");
2407 uri.SetQueryString(ss.str());
2408 return GetObjectTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2409 }
2410
GetObjectTaggingCallable(const GetObjectTaggingRequest & request) const2411 GetObjectTaggingOutcomeCallable S3CrtClient::GetObjectTaggingCallable(const GetObjectTaggingRequest& request) const
2412 {
2413 auto task = Aws::MakeShared< std::packaged_task< GetObjectTaggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectTagging(request); } );
2414 auto packagedFunction = [task]() { (*task)(); };
2415 m_executor->Submit(packagedFunction);
2416 return task->get_future();
2417 }
2418
GetObjectTaggingAsync(const GetObjectTaggingRequest & request,const GetObjectTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2419 void S3CrtClient::GetObjectTaggingAsync(const GetObjectTaggingRequest& request, const GetObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2420 {
2421 m_executor->Submit( [this, request, handler, context](){ this->GetObjectTaggingAsyncHelper( request, handler, context ); } );
2422 }
2423
GetObjectTaggingAsyncHelper(const GetObjectTaggingRequest & request,const GetObjectTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2424 void S3CrtClient::GetObjectTaggingAsyncHelper(const GetObjectTaggingRequest& request, const GetObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2425 {
2426 handler(this, request, GetObjectTagging(request), context);
2427 }
2428
GetObjectTorrent(const GetObjectTorrentRequest & request) const2429 GetObjectTorrentOutcome S3CrtClient::GetObjectTorrent(const GetObjectTorrentRequest& request) const
2430 {
2431 if (!request.BucketHasBeenSet())
2432 {
2433 AWS_LOGSTREAM_ERROR("GetObjectTorrent", "Required field: Bucket, is not set");
2434 return GetObjectTorrentOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2435 }
2436 if (!request.KeyHasBeenSet())
2437 {
2438 AWS_LOGSTREAM_ERROR("GetObjectTorrent", "Required field: Key, is not set");
2439 return GetObjectTorrentOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2440 }
2441 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2442 if (!computeEndpointOutcome.IsSuccess())
2443 {
2444 return GetObjectTorrentOutcome(computeEndpointOutcome.GetError());
2445 }
2446 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2447 Aws::StringStream ss;
2448 uri.AddPathSegments(request.GetKey());
2449 ss.str("?torrent");
2450 uri.SetQueryString(ss.str());
2451 return GetObjectTorrentOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2452 }
2453
GetObjectTorrentCallable(const GetObjectTorrentRequest & request) const2454 GetObjectTorrentOutcomeCallable S3CrtClient::GetObjectTorrentCallable(const GetObjectTorrentRequest& request) const
2455 {
2456 auto task = Aws::MakeShared< std::packaged_task< GetObjectTorrentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectTorrent(request); } );
2457 auto packagedFunction = [task]() { (*task)(); };
2458 m_executor->Submit(packagedFunction);
2459 return task->get_future();
2460 }
2461
GetObjectTorrentAsync(const GetObjectTorrentRequest & request,const GetObjectTorrentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2462 void S3CrtClient::GetObjectTorrentAsync(const GetObjectTorrentRequest& request, const GetObjectTorrentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2463 {
2464 m_executor->Submit( [this, request, handler, context](){ this->GetObjectTorrentAsyncHelper( request, handler, context ); } );
2465 }
2466
GetObjectTorrentAsyncHelper(const GetObjectTorrentRequest & request,const GetObjectTorrentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2467 void S3CrtClient::GetObjectTorrentAsyncHelper(const GetObjectTorrentRequest& request, const GetObjectTorrentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2468 {
2469 handler(this, request, GetObjectTorrent(request), context);
2470 }
2471
GetPublicAccessBlock(const GetPublicAccessBlockRequest & request) const2472 GetPublicAccessBlockOutcome S3CrtClient::GetPublicAccessBlock(const GetPublicAccessBlockRequest& request) const
2473 {
2474 if (!request.BucketHasBeenSet())
2475 {
2476 AWS_LOGSTREAM_ERROR("GetPublicAccessBlock", "Required field: Bucket, is not set");
2477 return GetPublicAccessBlockOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2478 }
2479 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2480 if (!computeEndpointOutcome.IsSuccess())
2481 {
2482 return GetPublicAccessBlockOutcome(computeEndpointOutcome.GetError());
2483 }
2484 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2485 Aws::StringStream ss;
2486 ss.str("?publicAccessBlock");
2487 uri.SetQueryString(ss.str());
2488 return GetPublicAccessBlockOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2489 }
2490
GetPublicAccessBlockCallable(const GetPublicAccessBlockRequest & request) const2491 GetPublicAccessBlockOutcomeCallable S3CrtClient::GetPublicAccessBlockCallable(const GetPublicAccessBlockRequest& request) const
2492 {
2493 auto task = Aws::MakeShared< std::packaged_task< GetPublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPublicAccessBlock(request); } );
2494 auto packagedFunction = [task]() { (*task)(); };
2495 m_executor->Submit(packagedFunction);
2496 return task->get_future();
2497 }
2498
GetPublicAccessBlockAsync(const GetPublicAccessBlockRequest & request,const GetPublicAccessBlockResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2499 void S3CrtClient::GetPublicAccessBlockAsync(const GetPublicAccessBlockRequest& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2500 {
2501 m_executor->Submit( [this, request, handler, context](){ this->GetPublicAccessBlockAsyncHelper( request, handler, context ); } );
2502 }
2503
GetPublicAccessBlockAsyncHelper(const GetPublicAccessBlockRequest & request,const GetPublicAccessBlockResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2504 void S3CrtClient::GetPublicAccessBlockAsyncHelper(const GetPublicAccessBlockRequest& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2505 {
2506 handler(this, request, GetPublicAccessBlock(request), context);
2507 }
2508
HeadBucket(const HeadBucketRequest & request) const2509 HeadBucketOutcome S3CrtClient::HeadBucket(const HeadBucketRequest& request) const
2510 {
2511 if (!request.BucketHasBeenSet())
2512 {
2513 AWS_LOGSTREAM_ERROR("HeadBucket", "Required field: Bucket, is not set");
2514 return HeadBucketOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2515 }
2516 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2517 if (!computeEndpointOutcome.IsSuccess())
2518 {
2519 return HeadBucketOutcome(computeEndpointOutcome.GetError());
2520 }
2521 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2522 return HeadBucketOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_HEAD, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2523 }
2524
HeadBucketCallable(const HeadBucketRequest & request) const2525 HeadBucketOutcomeCallable S3CrtClient::HeadBucketCallable(const HeadBucketRequest& request) const
2526 {
2527 auto task = Aws::MakeShared< std::packaged_task< HeadBucketOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->HeadBucket(request); } );
2528 auto packagedFunction = [task]() { (*task)(); };
2529 m_executor->Submit(packagedFunction);
2530 return task->get_future();
2531 }
2532
HeadBucketAsync(const HeadBucketRequest & request,const HeadBucketResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2533 void S3CrtClient::HeadBucketAsync(const HeadBucketRequest& request, const HeadBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2534 {
2535 m_executor->Submit( [this, request, handler, context](){ this->HeadBucketAsyncHelper( request, handler, context ); } );
2536 }
2537
HeadBucketAsyncHelper(const HeadBucketRequest & request,const HeadBucketResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2538 void S3CrtClient::HeadBucketAsyncHelper(const HeadBucketRequest& request, const HeadBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2539 {
2540 handler(this, request, HeadBucket(request), context);
2541 }
2542
HeadObject(const HeadObjectRequest & request) const2543 HeadObjectOutcome S3CrtClient::HeadObject(const HeadObjectRequest& request) const
2544 {
2545 if (!request.BucketHasBeenSet())
2546 {
2547 AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Bucket, is not set");
2548 return HeadObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2549 }
2550 if (!request.KeyHasBeenSet())
2551 {
2552 AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Key, is not set");
2553 return HeadObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2554 }
2555 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2556 if (!computeEndpointOutcome.IsSuccess())
2557 {
2558 return HeadObjectOutcome(computeEndpointOutcome.GetError());
2559 }
2560 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2561 uri.AddPathSegments(request.GetKey());
2562 return HeadObjectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_HEAD, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2563 }
2564
HeadObjectCallable(const HeadObjectRequest & request) const2565 HeadObjectOutcomeCallable S3CrtClient::HeadObjectCallable(const HeadObjectRequest& request) const
2566 {
2567 auto task = Aws::MakeShared< std::packaged_task< HeadObjectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->HeadObject(request); } );
2568 auto packagedFunction = [task]() { (*task)(); };
2569 m_executor->Submit(packagedFunction);
2570 return task->get_future();
2571 }
2572
HeadObjectAsync(const HeadObjectRequest & request,const HeadObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2573 void S3CrtClient::HeadObjectAsync(const HeadObjectRequest& request, const HeadObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2574 {
2575 m_executor->Submit( [this, request, handler, context](){ this->HeadObjectAsyncHelper( request, handler, context ); } );
2576 }
2577
HeadObjectAsyncHelper(const HeadObjectRequest & request,const HeadObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2578 void S3CrtClient::HeadObjectAsyncHelper(const HeadObjectRequest& request, const HeadObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2579 {
2580 handler(this, request, HeadObject(request), context);
2581 }
2582
ListBucketAnalyticsConfigurations(const ListBucketAnalyticsConfigurationsRequest & request) const2583 ListBucketAnalyticsConfigurationsOutcome S3CrtClient::ListBucketAnalyticsConfigurations(const ListBucketAnalyticsConfigurationsRequest& request) const
2584 {
2585 if (!request.BucketHasBeenSet())
2586 {
2587 AWS_LOGSTREAM_ERROR("ListBucketAnalyticsConfigurations", "Required field: Bucket, is not set");
2588 return ListBucketAnalyticsConfigurationsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2589 }
2590 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2591 if (!computeEndpointOutcome.IsSuccess())
2592 {
2593 return ListBucketAnalyticsConfigurationsOutcome(computeEndpointOutcome.GetError());
2594 }
2595 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2596 Aws::StringStream ss;
2597 ss.str("?analytics");
2598 uri.SetQueryString(ss.str());
2599 return ListBucketAnalyticsConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2600 }
2601
ListBucketAnalyticsConfigurationsCallable(const ListBucketAnalyticsConfigurationsRequest & request) const2602 ListBucketAnalyticsConfigurationsOutcomeCallable S3CrtClient::ListBucketAnalyticsConfigurationsCallable(const ListBucketAnalyticsConfigurationsRequest& request) const
2603 {
2604 auto task = Aws::MakeShared< std::packaged_task< ListBucketAnalyticsConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListBucketAnalyticsConfigurations(request); } );
2605 auto packagedFunction = [task]() { (*task)(); };
2606 m_executor->Submit(packagedFunction);
2607 return task->get_future();
2608 }
2609
ListBucketAnalyticsConfigurationsAsync(const ListBucketAnalyticsConfigurationsRequest & request,const ListBucketAnalyticsConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2610 void S3CrtClient::ListBucketAnalyticsConfigurationsAsync(const ListBucketAnalyticsConfigurationsRequest& request, const ListBucketAnalyticsConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2611 {
2612 m_executor->Submit( [this, request, handler, context](){ this->ListBucketAnalyticsConfigurationsAsyncHelper( request, handler, context ); } );
2613 }
2614
ListBucketAnalyticsConfigurationsAsyncHelper(const ListBucketAnalyticsConfigurationsRequest & request,const ListBucketAnalyticsConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2615 void S3CrtClient::ListBucketAnalyticsConfigurationsAsyncHelper(const ListBucketAnalyticsConfigurationsRequest& request, const ListBucketAnalyticsConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2616 {
2617 handler(this, request, ListBucketAnalyticsConfigurations(request), context);
2618 }
2619
ListBucketIntelligentTieringConfigurations(const ListBucketIntelligentTieringConfigurationsRequest & request) const2620 ListBucketIntelligentTieringConfigurationsOutcome S3CrtClient::ListBucketIntelligentTieringConfigurations(const ListBucketIntelligentTieringConfigurationsRequest& request) const
2621 {
2622 if (!request.BucketHasBeenSet())
2623 {
2624 AWS_LOGSTREAM_ERROR("ListBucketIntelligentTieringConfigurations", "Required field: Bucket, is not set");
2625 return ListBucketIntelligentTieringConfigurationsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2626 }
2627 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2628 if (!computeEndpointOutcome.IsSuccess())
2629 {
2630 return ListBucketIntelligentTieringConfigurationsOutcome(computeEndpointOutcome.GetError());
2631 }
2632 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2633 Aws::StringStream ss;
2634 ss.str("?intelligent-tiering");
2635 uri.SetQueryString(ss.str());
2636 return ListBucketIntelligentTieringConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2637 }
2638
ListBucketIntelligentTieringConfigurationsCallable(const ListBucketIntelligentTieringConfigurationsRequest & request) const2639 ListBucketIntelligentTieringConfigurationsOutcomeCallable S3CrtClient::ListBucketIntelligentTieringConfigurationsCallable(const ListBucketIntelligentTieringConfigurationsRequest& request) const
2640 {
2641 auto task = Aws::MakeShared< std::packaged_task< ListBucketIntelligentTieringConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListBucketIntelligentTieringConfigurations(request); } );
2642 auto packagedFunction = [task]() { (*task)(); };
2643 m_executor->Submit(packagedFunction);
2644 return task->get_future();
2645 }
2646
ListBucketIntelligentTieringConfigurationsAsync(const ListBucketIntelligentTieringConfigurationsRequest & request,const ListBucketIntelligentTieringConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2647 void S3CrtClient::ListBucketIntelligentTieringConfigurationsAsync(const ListBucketIntelligentTieringConfigurationsRequest& request, const ListBucketIntelligentTieringConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2648 {
2649 m_executor->Submit( [this, request, handler, context](){ this->ListBucketIntelligentTieringConfigurationsAsyncHelper( request, handler, context ); } );
2650 }
2651
ListBucketIntelligentTieringConfigurationsAsyncHelper(const ListBucketIntelligentTieringConfigurationsRequest & request,const ListBucketIntelligentTieringConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2652 void S3CrtClient::ListBucketIntelligentTieringConfigurationsAsyncHelper(const ListBucketIntelligentTieringConfigurationsRequest& request, const ListBucketIntelligentTieringConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2653 {
2654 handler(this, request, ListBucketIntelligentTieringConfigurations(request), context);
2655 }
2656
ListBucketInventoryConfigurations(const ListBucketInventoryConfigurationsRequest & request) const2657 ListBucketInventoryConfigurationsOutcome S3CrtClient::ListBucketInventoryConfigurations(const ListBucketInventoryConfigurationsRequest& request) const
2658 {
2659 if (!request.BucketHasBeenSet())
2660 {
2661 AWS_LOGSTREAM_ERROR("ListBucketInventoryConfigurations", "Required field: Bucket, is not set");
2662 return ListBucketInventoryConfigurationsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2663 }
2664 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2665 if (!computeEndpointOutcome.IsSuccess())
2666 {
2667 return ListBucketInventoryConfigurationsOutcome(computeEndpointOutcome.GetError());
2668 }
2669 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2670 Aws::StringStream ss;
2671 ss.str("?inventory");
2672 uri.SetQueryString(ss.str());
2673 return ListBucketInventoryConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2674 }
2675
ListBucketInventoryConfigurationsCallable(const ListBucketInventoryConfigurationsRequest & request) const2676 ListBucketInventoryConfigurationsOutcomeCallable S3CrtClient::ListBucketInventoryConfigurationsCallable(const ListBucketInventoryConfigurationsRequest& request) const
2677 {
2678 auto task = Aws::MakeShared< std::packaged_task< ListBucketInventoryConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListBucketInventoryConfigurations(request); } );
2679 auto packagedFunction = [task]() { (*task)(); };
2680 m_executor->Submit(packagedFunction);
2681 return task->get_future();
2682 }
2683
ListBucketInventoryConfigurationsAsync(const ListBucketInventoryConfigurationsRequest & request,const ListBucketInventoryConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2684 void S3CrtClient::ListBucketInventoryConfigurationsAsync(const ListBucketInventoryConfigurationsRequest& request, const ListBucketInventoryConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2685 {
2686 m_executor->Submit( [this, request, handler, context](){ this->ListBucketInventoryConfigurationsAsyncHelper( request, handler, context ); } );
2687 }
2688
ListBucketInventoryConfigurationsAsyncHelper(const ListBucketInventoryConfigurationsRequest & request,const ListBucketInventoryConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2689 void S3CrtClient::ListBucketInventoryConfigurationsAsyncHelper(const ListBucketInventoryConfigurationsRequest& request, const ListBucketInventoryConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2690 {
2691 handler(this, request, ListBucketInventoryConfigurations(request), context);
2692 }
2693
ListBucketMetricsConfigurations(const ListBucketMetricsConfigurationsRequest & request) const2694 ListBucketMetricsConfigurationsOutcome S3CrtClient::ListBucketMetricsConfigurations(const ListBucketMetricsConfigurationsRequest& request) const
2695 {
2696 if (!request.BucketHasBeenSet())
2697 {
2698 AWS_LOGSTREAM_ERROR("ListBucketMetricsConfigurations", "Required field: Bucket, is not set");
2699 return ListBucketMetricsConfigurationsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2700 }
2701 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2702 if (!computeEndpointOutcome.IsSuccess())
2703 {
2704 return ListBucketMetricsConfigurationsOutcome(computeEndpointOutcome.GetError());
2705 }
2706 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2707 Aws::StringStream ss;
2708 ss.str("?metrics");
2709 uri.SetQueryString(ss.str());
2710 return ListBucketMetricsConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2711 }
2712
ListBucketMetricsConfigurationsCallable(const ListBucketMetricsConfigurationsRequest & request) const2713 ListBucketMetricsConfigurationsOutcomeCallable S3CrtClient::ListBucketMetricsConfigurationsCallable(const ListBucketMetricsConfigurationsRequest& request) const
2714 {
2715 auto task = Aws::MakeShared< std::packaged_task< ListBucketMetricsConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListBucketMetricsConfigurations(request); } );
2716 auto packagedFunction = [task]() { (*task)(); };
2717 m_executor->Submit(packagedFunction);
2718 return task->get_future();
2719 }
2720
ListBucketMetricsConfigurationsAsync(const ListBucketMetricsConfigurationsRequest & request,const ListBucketMetricsConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2721 void S3CrtClient::ListBucketMetricsConfigurationsAsync(const ListBucketMetricsConfigurationsRequest& request, const ListBucketMetricsConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2722 {
2723 m_executor->Submit( [this, request, handler, context](){ this->ListBucketMetricsConfigurationsAsyncHelper( request, handler, context ); } );
2724 }
2725
ListBucketMetricsConfigurationsAsyncHelper(const ListBucketMetricsConfigurationsRequest & request,const ListBucketMetricsConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2726 void S3CrtClient::ListBucketMetricsConfigurationsAsyncHelper(const ListBucketMetricsConfigurationsRequest& request, const ListBucketMetricsConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2727 {
2728 handler(this, request, ListBucketMetricsConfigurations(request), context);
2729 }
2730
ListBuckets() const2731 ListBucketsOutcome S3CrtClient::ListBuckets() const
2732 {
2733 Aws::StringStream ss;
2734 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString();
2735 if (!computeEndpointOutcome.IsSuccess())
2736 {
2737 return ListBucketsOutcome(computeEndpointOutcome.GetError());
2738 }
2739 ss << computeEndpointOutcome.GetResult().endpoint;
2740 return ListBucketsOutcome(MakeRequest(ss.str(), Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, "ListBuckets", computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2741 }
2742
ListBucketsCallable() const2743 ListBucketsOutcomeCallable S3CrtClient::ListBucketsCallable() const
2744 {
2745 auto task = Aws::MakeShared< std::packaged_task< ListBucketsOutcome() > >(ALLOCATION_TAG, [this](){ return this->ListBuckets(); } );
2746 auto packagedFunction = [task]() { (*task)(); };
2747 m_executor->Submit(packagedFunction);
2748 return task->get_future();
2749 }
2750
ListBucketsAsync(const ListBucketsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2751 void S3CrtClient::ListBucketsAsync(const ListBucketsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2752 {
2753 m_executor->Submit( [this, handler, context](){ this->ListBucketsAsyncHelper( handler, context ); } );
2754 }
2755
ListBucketsAsyncHelper(const ListBucketsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2756 void S3CrtClient::ListBucketsAsyncHelper(const ListBucketsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2757 {
2758 handler(this, ListBuckets(), context);
2759 }
2760
ListMultipartUploads(const ListMultipartUploadsRequest & request) const2761 ListMultipartUploadsOutcome S3CrtClient::ListMultipartUploads(const ListMultipartUploadsRequest& request) const
2762 {
2763 if (!request.BucketHasBeenSet())
2764 {
2765 AWS_LOGSTREAM_ERROR("ListMultipartUploads", "Required field: Bucket, is not set");
2766 return ListMultipartUploadsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2767 }
2768 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2769 if (!computeEndpointOutcome.IsSuccess())
2770 {
2771 return ListMultipartUploadsOutcome(computeEndpointOutcome.GetError());
2772 }
2773 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2774 Aws::StringStream ss;
2775 ss.str("?uploads");
2776 uri.SetQueryString(ss.str());
2777 return ListMultipartUploadsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2778 }
2779
ListMultipartUploadsCallable(const ListMultipartUploadsRequest & request) const2780 ListMultipartUploadsOutcomeCallable S3CrtClient::ListMultipartUploadsCallable(const ListMultipartUploadsRequest& request) const
2781 {
2782 auto task = Aws::MakeShared< std::packaged_task< ListMultipartUploadsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMultipartUploads(request); } );
2783 auto packagedFunction = [task]() { (*task)(); };
2784 m_executor->Submit(packagedFunction);
2785 return task->get_future();
2786 }
2787
ListMultipartUploadsAsync(const ListMultipartUploadsRequest & request,const ListMultipartUploadsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2788 void S3CrtClient::ListMultipartUploadsAsync(const ListMultipartUploadsRequest& request, const ListMultipartUploadsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2789 {
2790 m_executor->Submit( [this, request, handler, context](){ this->ListMultipartUploadsAsyncHelper( request, handler, context ); } );
2791 }
2792
ListMultipartUploadsAsyncHelper(const ListMultipartUploadsRequest & request,const ListMultipartUploadsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2793 void S3CrtClient::ListMultipartUploadsAsyncHelper(const ListMultipartUploadsRequest& request, const ListMultipartUploadsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2794 {
2795 handler(this, request, ListMultipartUploads(request), context);
2796 }
2797
ListObjectVersions(const ListObjectVersionsRequest & request) const2798 ListObjectVersionsOutcome S3CrtClient::ListObjectVersions(const ListObjectVersionsRequest& request) const
2799 {
2800 if (!request.BucketHasBeenSet())
2801 {
2802 AWS_LOGSTREAM_ERROR("ListObjectVersions", "Required field: Bucket, is not set");
2803 return ListObjectVersionsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2804 }
2805 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2806 if (!computeEndpointOutcome.IsSuccess())
2807 {
2808 return ListObjectVersionsOutcome(computeEndpointOutcome.GetError());
2809 }
2810 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2811 Aws::StringStream ss;
2812 ss.str("?versions");
2813 uri.SetQueryString(ss.str());
2814 return ListObjectVersionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2815 }
2816
ListObjectVersionsCallable(const ListObjectVersionsRequest & request) const2817 ListObjectVersionsOutcomeCallable S3CrtClient::ListObjectVersionsCallable(const ListObjectVersionsRequest& request) const
2818 {
2819 auto task = Aws::MakeShared< std::packaged_task< ListObjectVersionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListObjectVersions(request); } );
2820 auto packagedFunction = [task]() { (*task)(); };
2821 m_executor->Submit(packagedFunction);
2822 return task->get_future();
2823 }
2824
ListObjectVersionsAsync(const ListObjectVersionsRequest & request,const ListObjectVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2825 void S3CrtClient::ListObjectVersionsAsync(const ListObjectVersionsRequest& request, const ListObjectVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2826 {
2827 m_executor->Submit( [this, request, handler, context](){ this->ListObjectVersionsAsyncHelper( request, handler, context ); } );
2828 }
2829
ListObjectVersionsAsyncHelper(const ListObjectVersionsRequest & request,const ListObjectVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2830 void S3CrtClient::ListObjectVersionsAsyncHelper(const ListObjectVersionsRequest& request, const ListObjectVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2831 {
2832 handler(this, request, ListObjectVersions(request), context);
2833 }
2834
ListObjects(const ListObjectsRequest & request) const2835 ListObjectsOutcome S3CrtClient::ListObjects(const ListObjectsRequest& request) const
2836 {
2837 if (!request.BucketHasBeenSet())
2838 {
2839 AWS_LOGSTREAM_ERROR("ListObjects", "Required field: Bucket, is not set");
2840 return ListObjectsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2841 }
2842 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2843 if (!computeEndpointOutcome.IsSuccess())
2844 {
2845 return ListObjectsOutcome(computeEndpointOutcome.GetError());
2846 }
2847 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2848 return ListObjectsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2849 }
2850
ListObjectsCallable(const ListObjectsRequest & request) const2851 ListObjectsOutcomeCallable S3CrtClient::ListObjectsCallable(const ListObjectsRequest& request) const
2852 {
2853 auto task = Aws::MakeShared< std::packaged_task< ListObjectsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListObjects(request); } );
2854 auto packagedFunction = [task]() { (*task)(); };
2855 m_executor->Submit(packagedFunction);
2856 return task->get_future();
2857 }
2858
ListObjectsAsync(const ListObjectsRequest & request,const ListObjectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2859 void S3CrtClient::ListObjectsAsync(const ListObjectsRequest& request, const ListObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2860 {
2861 m_executor->Submit( [this, request, handler, context](){ this->ListObjectsAsyncHelper( request, handler, context ); } );
2862 }
2863
ListObjectsAsyncHelper(const ListObjectsRequest & request,const ListObjectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2864 void S3CrtClient::ListObjectsAsyncHelper(const ListObjectsRequest& request, const ListObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2865 {
2866 handler(this, request, ListObjects(request), context);
2867 }
2868
ListObjectsV2(const ListObjectsV2Request & request) const2869 ListObjectsV2Outcome S3CrtClient::ListObjectsV2(const ListObjectsV2Request& request) const
2870 {
2871 if (!request.BucketHasBeenSet())
2872 {
2873 AWS_LOGSTREAM_ERROR("ListObjectsV2", "Required field: Bucket, is not set");
2874 return ListObjectsV2Outcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2875 }
2876 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2877 if (!computeEndpointOutcome.IsSuccess())
2878 {
2879 return ListObjectsV2Outcome(computeEndpointOutcome.GetError());
2880 }
2881 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2882 Aws::StringStream ss;
2883 ss.str("?list-type=2");
2884 uri.SetQueryString(ss.str());
2885 return ListObjectsV2Outcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2886 }
2887
ListObjectsV2Callable(const ListObjectsV2Request & request) const2888 ListObjectsV2OutcomeCallable S3CrtClient::ListObjectsV2Callable(const ListObjectsV2Request& request) const
2889 {
2890 auto task = Aws::MakeShared< std::packaged_task< ListObjectsV2Outcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListObjectsV2(request); } );
2891 auto packagedFunction = [task]() { (*task)(); };
2892 m_executor->Submit(packagedFunction);
2893 return task->get_future();
2894 }
2895
ListObjectsV2Async(const ListObjectsV2Request & request,const ListObjectsV2ResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2896 void S3CrtClient::ListObjectsV2Async(const ListObjectsV2Request& request, const ListObjectsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2897 {
2898 m_executor->Submit( [this, request, handler, context](){ this->ListObjectsV2AsyncHelper( request, handler, context ); } );
2899 }
2900
ListObjectsV2AsyncHelper(const ListObjectsV2Request & request,const ListObjectsV2ResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2901 void S3CrtClient::ListObjectsV2AsyncHelper(const ListObjectsV2Request& request, const ListObjectsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2902 {
2903 handler(this, request, ListObjectsV2(request), context);
2904 }
2905
ListParts(const ListPartsRequest & request) const2906 ListPartsOutcome S3CrtClient::ListParts(const ListPartsRequest& request) const
2907 {
2908 if (!request.BucketHasBeenSet())
2909 {
2910 AWS_LOGSTREAM_ERROR("ListParts", "Required field: Bucket, is not set");
2911 return ListPartsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2912 }
2913 if (!request.KeyHasBeenSet())
2914 {
2915 AWS_LOGSTREAM_ERROR("ListParts", "Required field: Key, is not set");
2916 return ListPartsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
2917 }
2918 if (!request.UploadIdHasBeenSet())
2919 {
2920 AWS_LOGSTREAM_ERROR("ListParts", "Required field: UploadId, is not set");
2921 return ListPartsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
2922 }
2923 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2924 if (!computeEndpointOutcome.IsSuccess())
2925 {
2926 return ListPartsOutcome(computeEndpointOutcome.GetError());
2927 }
2928 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2929 uri.AddPathSegments(request.GetKey());
2930 return ListPartsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2931 }
2932
ListPartsCallable(const ListPartsRequest & request) const2933 ListPartsOutcomeCallable S3CrtClient::ListPartsCallable(const ListPartsRequest& request) const
2934 {
2935 auto task = Aws::MakeShared< std::packaged_task< ListPartsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListParts(request); } );
2936 auto packagedFunction = [task]() { (*task)(); };
2937 m_executor->Submit(packagedFunction);
2938 return task->get_future();
2939 }
2940
ListPartsAsync(const ListPartsRequest & request,const ListPartsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2941 void S3CrtClient::ListPartsAsync(const ListPartsRequest& request, const ListPartsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2942 {
2943 m_executor->Submit( [this, request, handler, context](){ this->ListPartsAsyncHelper( request, handler, context ); } );
2944 }
2945
ListPartsAsyncHelper(const ListPartsRequest & request,const ListPartsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2946 void S3CrtClient::ListPartsAsyncHelper(const ListPartsRequest& request, const ListPartsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2947 {
2948 handler(this, request, ListParts(request), context);
2949 }
2950
PutBucketAccelerateConfiguration(const PutBucketAccelerateConfigurationRequest & request) const2951 PutBucketAccelerateConfigurationOutcome S3CrtClient::PutBucketAccelerateConfiguration(const PutBucketAccelerateConfigurationRequest& request) const
2952 {
2953 if (!request.BucketHasBeenSet())
2954 {
2955 AWS_LOGSTREAM_ERROR("PutBucketAccelerateConfiguration", "Required field: Bucket, is not set");
2956 return PutBucketAccelerateConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2957 }
2958 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2959 if (!computeEndpointOutcome.IsSuccess())
2960 {
2961 return PutBucketAccelerateConfigurationOutcome(computeEndpointOutcome.GetError());
2962 }
2963 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
2964 Aws::StringStream ss;
2965 ss.str("?accelerate");
2966 uri.SetQueryString(ss.str());
2967 return PutBucketAccelerateConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
2968 }
2969
PutBucketAccelerateConfigurationCallable(const PutBucketAccelerateConfigurationRequest & request) const2970 PutBucketAccelerateConfigurationOutcomeCallable S3CrtClient::PutBucketAccelerateConfigurationCallable(const PutBucketAccelerateConfigurationRequest& request) const
2971 {
2972 auto task = Aws::MakeShared< std::packaged_task< PutBucketAccelerateConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketAccelerateConfiguration(request); } );
2973 auto packagedFunction = [task]() { (*task)(); };
2974 m_executor->Submit(packagedFunction);
2975 return task->get_future();
2976 }
2977
PutBucketAccelerateConfigurationAsync(const PutBucketAccelerateConfigurationRequest & request,const PutBucketAccelerateConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2978 void S3CrtClient::PutBucketAccelerateConfigurationAsync(const PutBucketAccelerateConfigurationRequest& request, const PutBucketAccelerateConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2979 {
2980 m_executor->Submit( [this, request, handler, context](){ this->PutBucketAccelerateConfigurationAsyncHelper( request, handler, context ); } );
2981 }
2982
PutBucketAccelerateConfigurationAsyncHelper(const PutBucketAccelerateConfigurationRequest & request,const PutBucketAccelerateConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2983 void S3CrtClient::PutBucketAccelerateConfigurationAsyncHelper(const PutBucketAccelerateConfigurationRequest& request, const PutBucketAccelerateConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2984 {
2985 handler(this, request, PutBucketAccelerateConfiguration(request), context);
2986 }
2987
PutBucketAcl(const PutBucketAclRequest & request) const2988 PutBucketAclOutcome S3CrtClient::PutBucketAcl(const PutBucketAclRequest& request) const
2989 {
2990 if (!request.BucketHasBeenSet())
2991 {
2992 AWS_LOGSTREAM_ERROR("PutBucketAcl", "Required field: Bucket, is not set");
2993 return PutBucketAclOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
2994 }
2995 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
2996 if (!computeEndpointOutcome.IsSuccess())
2997 {
2998 return PutBucketAclOutcome(computeEndpointOutcome.GetError());
2999 }
3000 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3001 Aws::StringStream ss;
3002 ss.str("?acl");
3003 uri.SetQueryString(ss.str());
3004 return PutBucketAclOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3005 }
3006
PutBucketAclCallable(const PutBucketAclRequest & request) const3007 PutBucketAclOutcomeCallable S3CrtClient::PutBucketAclCallable(const PutBucketAclRequest& request) const
3008 {
3009 auto task = Aws::MakeShared< std::packaged_task< PutBucketAclOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketAcl(request); } );
3010 auto packagedFunction = [task]() { (*task)(); };
3011 m_executor->Submit(packagedFunction);
3012 return task->get_future();
3013 }
3014
PutBucketAclAsync(const PutBucketAclRequest & request,const PutBucketAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3015 void S3CrtClient::PutBucketAclAsync(const PutBucketAclRequest& request, const PutBucketAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3016 {
3017 m_executor->Submit( [this, request, handler, context](){ this->PutBucketAclAsyncHelper( request, handler, context ); } );
3018 }
3019
PutBucketAclAsyncHelper(const PutBucketAclRequest & request,const PutBucketAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3020 void S3CrtClient::PutBucketAclAsyncHelper(const PutBucketAclRequest& request, const PutBucketAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3021 {
3022 handler(this, request, PutBucketAcl(request), context);
3023 }
3024
PutBucketAnalyticsConfiguration(const PutBucketAnalyticsConfigurationRequest & request) const3025 PutBucketAnalyticsConfigurationOutcome S3CrtClient::PutBucketAnalyticsConfiguration(const PutBucketAnalyticsConfigurationRequest& request) const
3026 {
3027 if (!request.BucketHasBeenSet())
3028 {
3029 AWS_LOGSTREAM_ERROR("PutBucketAnalyticsConfiguration", "Required field: Bucket, is not set");
3030 return PutBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3031 }
3032 if (!request.IdHasBeenSet())
3033 {
3034 AWS_LOGSTREAM_ERROR("PutBucketAnalyticsConfiguration", "Required field: Id, is not set");
3035 return PutBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
3036 }
3037 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3038 if (!computeEndpointOutcome.IsSuccess())
3039 {
3040 return PutBucketAnalyticsConfigurationOutcome(computeEndpointOutcome.GetError());
3041 }
3042 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3043 Aws::StringStream ss;
3044 ss.str("?analytics");
3045 uri.SetQueryString(ss.str());
3046 return PutBucketAnalyticsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3047 }
3048
PutBucketAnalyticsConfigurationCallable(const PutBucketAnalyticsConfigurationRequest & request) const3049 PutBucketAnalyticsConfigurationOutcomeCallable S3CrtClient::PutBucketAnalyticsConfigurationCallable(const PutBucketAnalyticsConfigurationRequest& request) const
3050 {
3051 auto task = Aws::MakeShared< std::packaged_task< PutBucketAnalyticsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketAnalyticsConfiguration(request); } );
3052 auto packagedFunction = [task]() { (*task)(); };
3053 m_executor->Submit(packagedFunction);
3054 return task->get_future();
3055 }
3056
PutBucketAnalyticsConfigurationAsync(const PutBucketAnalyticsConfigurationRequest & request,const PutBucketAnalyticsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3057 void S3CrtClient::PutBucketAnalyticsConfigurationAsync(const PutBucketAnalyticsConfigurationRequest& request, const PutBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3058 {
3059 m_executor->Submit( [this, request, handler, context](){ this->PutBucketAnalyticsConfigurationAsyncHelper( request, handler, context ); } );
3060 }
3061
PutBucketAnalyticsConfigurationAsyncHelper(const PutBucketAnalyticsConfigurationRequest & request,const PutBucketAnalyticsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3062 void S3CrtClient::PutBucketAnalyticsConfigurationAsyncHelper(const PutBucketAnalyticsConfigurationRequest& request, const PutBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3063 {
3064 handler(this, request, PutBucketAnalyticsConfiguration(request), context);
3065 }
3066
PutBucketCors(const PutBucketCorsRequest & request) const3067 PutBucketCorsOutcome S3CrtClient::PutBucketCors(const PutBucketCorsRequest& request) const
3068 {
3069 if (!request.BucketHasBeenSet())
3070 {
3071 AWS_LOGSTREAM_ERROR("PutBucketCors", "Required field: Bucket, is not set");
3072 return PutBucketCorsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3073 }
3074 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3075 if (!computeEndpointOutcome.IsSuccess())
3076 {
3077 return PutBucketCorsOutcome(computeEndpointOutcome.GetError());
3078 }
3079 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3080 Aws::StringStream ss;
3081 ss.str("?cors");
3082 uri.SetQueryString(ss.str());
3083 return PutBucketCorsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3084 }
3085
PutBucketCorsCallable(const PutBucketCorsRequest & request) const3086 PutBucketCorsOutcomeCallable S3CrtClient::PutBucketCorsCallable(const PutBucketCorsRequest& request) const
3087 {
3088 auto task = Aws::MakeShared< std::packaged_task< PutBucketCorsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketCors(request); } );
3089 auto packagedFunction = [task]() { (*task)(); };
3090 m_executor->Submit(packagedFunction);
3091 return task->get_future();
3092 }
3093
PutBucketCorsAsync(const PutBucketCorsRequest & request,const PutBucketCorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3094 void S3CrtClient::PutBucketCorsAsync(const PutBucketCorsRequest& request, const PutBucketCorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3095 {
3096 m_executor->Submit( [this, request, handler, context](){ this->PutBucketCorsAsyncHelper( request, handler, context ); } );
3097 }
3098
PutBucketCorsAsyncHelper(const PutBucketCorsRequest & request,const PutBucketCorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3099 void S3CrtClient::PutBucketCorsAsyncHelper(const PutBucketCorsRequest& request, const PutBucketCorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3100 {
3101 handler(this, request, PutBucketCors(request), context);
3102 }
3103
PutBucketEncryption(const PutBucketEncryptionRequest & request) const3104 PutBucketEncryptionOutcome S3CrtClient::PutBucketEncryption(const PutBucketEncryptionRequest& request) const
3105 {
3106 if (!request.BucketHasBeenSet())
3107 {
3108 AWS_LOGSTREAM_ERROR("PutBucketEncryption", "Required field: Bucket, is not set");
3109 return PutBucketEncryptionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3110 }
3111 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3112 if (!computeEndpointOutcome.IsSuccess())
3113 {
3114 return PutBucketEncryptionOutcome(computeEndpointOutcome.GetError());
3115 }
3116 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3117 Aws::StringStream ss;
3118 ss.str("?encryption");
3119 uri.SetQueryString(ss.str());
3120 return PutBucketEncryptionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3121 }
3122
PutBucketEncryptionCallable(const PutBucketEncryptionRequest & request) const3123 PutBucketEncryptionOutcomeCallable S3CrtClient::PutBucketEncryptionCallable(const PutBucketEncryptionRequest& request) const
3124 {
3125 auto task = Aws::MakeShared< std::packaged_task< PutBucketEncryptionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketEncryption(request); } );
3126 auto packagedFunction = [task]() { (*task)(); };
3127 m_executor->Submit(packagedFunction);
3128 return task->get_future();
3129 }
3130
PutBucketEncryptionAsync(const PutBucketEncryptionRequest & request,const PutBucketEncryptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3131 void S3CrtClient::PutBucketEncryptionAsync(const PutBucketEncryptionRequest& request, const PutBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3132 {
3133 m_executor->Submit( [this, request, handler, context](){ this->PutBucketEncryptionAsyncHelper( request, handler, context ); } );
3134 }
3135
PutBucketEncryptionAsyncHelper(const PutBucketEncryptionRequest & request,const PutBucketEncryptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3136 void S3CrtClient::PutBucketEncryptionAsyncHelper(const PutBucketEncryptionRequest& request, const PutBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3137 {
3138 handler(this, request, PutBucketEncryption(request), context);
3139 }
3140
PutBucketIntelligentTieringConfiguration(const PutBucketIntelligentTieringConfigurationRequest & request) const3141 PutBucketIntelligentTieringConfigurationOutcome S3CrtClient::PutBucketIntelligentTieringConfiguration(const PutBucketIntelligentTieringConfigurationRequest& request) const
3142 {
3143 if (!request.BucketHasBeenSet())
3144 {
3145 AWS_LOGSTREAM_ERROR("PutBucketIntelligentTieringConfiguration", "Required field: Bucket, is not set");
3146 return PutBucketIntelligentTieringConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3147 }
3148 if (!request.IdHasBeenSet())
3149 {
3150 AWS_LOGSTREAM_ERROR("PutBucketIntelligentTieringConfiguration", "Required field: Id, is not set");
3151 return PutBucketIntelligentTieringConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
3152 }
3153 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3154 if (!computeEndpointOutcome.IsSuccess())
3155 {
3156 return PutBucketIntelligentTieringConfigurationOutcome(computeEndpointOutcome.GetError());
3157 }
3158 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3159 Aws::StringStream ss;
3160 ss.str("?intelligent-tiering");
3161 uri.SetQueryString(ss.str());
3162 return PutBucketIntelligentTieringConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3163 }
3164
PutBucketIntelligentTieringConfigurationCallable(const PutBucketIntelligentTieringConfigurationRequest & request) const3165 PutBucketIntelligentTieringConfigurationOutcomeCallable S3CrtClient::PutBucketIntelligentTieringConfigurationCallable(const PutBucketIntelligentTieringConfigurationRequest& request) const
3166 {
3167 auto task = Aws::MakeShared< std::packaged_task< PutBucketIntelligentTieringConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketIntelligentTieringConfiguration(request); } );
3168 auto packagedFunction = [task]() { (*task)(); };
3169 m_executor->Submit(packagedFunction);
3170 return task->get_future();
3171 }
3172
PutBucketIntelligentTieringConfigurationAsync(const PutBucketIntelligentTieringConfigurationRequest & request,const PutBucketIntelligentTieringConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3173 void S3CrtClient::PutBucketIntelligentTieringConfigurationAsync(const PutBucketIntelligentTieringConfigurationRequest& request, const PutBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3174 {
3175 m_executor->Submit( [this, request, handler, context](){ this->PutBucketIntelligentTieringConfigurationAsyncHelper( request, handler, context ); } );
3176 }
3177
PutBucketIntelligentTieringConfigurationAsyncHelper(const PutBucketIntelligentTieringConfigurationRequest & request,const PutBucketIntelligentTieringConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3178 void S3CrtClient::PutBucketIntelligentTieringConfigurationAsyncHelper(const PutBucketIntelligentTieringConfigurationRequest& request, const PutBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3179 {
3180 handler(this, request, PutBucketIntelligentTieringConfiguration(request), context);
3181 }
3182
PutBucketInventoryConfiguration(const PutBucketInventoryConfigurationRequest & request) const3183 PutBucketInventoryConfigurationOutcome S3CrtClient::PutBucketInventoryConfiguration(const PutBucketInventoryConfigurationRequest& request) const
3184 {
3185 if (!request.BucketHasBeenSet())
3186 {
3187 AWS_LOGSTREAM_ERROR("PutBucketInventoryConfiguration", "Required field: Bucket, is not set");
3188 return PutBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3189 }
3190 if (!request.IdHasBeenSet())
3191 {
3192 AWS_LOGSTREAM_ERROR("PutBucketInventoryConfiguration", "Required field: Id, is not set");
3193 return PutBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
3194 }
3195 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3196 if (!computeEndpointOutcome.IsSuccess())
3197 {
3198 return PutBucketInventoryConfigurationOutcome(computeEndpointOutcome.GetError());
3199 }
3200 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3201 Aws::StringStream ss;
3202 ss.str("?inventory");
3203 uri.SetQueryString(ss.str());
3204 return PutBucketInventoryConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3205 }
3206
PutBucketInventoryConfigurationCallable(const PutBucketInventoryConfigurationRequest & request) const3207 PutBucketInventoryConfigurationOutcomeCallable S3CrtClient::PutBucketInventoryConfigurationCallable(const PutBucketInventoryConfigurationRequest& request) const
3208 {
3209 auto task = Aws::MakeShared< std::packaged_task< PutBucketInventoryConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketInventoryConfiguration(request); } );
3210 auto packagedFunction = [task]() { (*task)(); };
3211 m_executor->Submit(packagedFunction);
3212 return task->get_future();
3213 }
3214
PutBucketInventoryConfigurationAsync(const PutBucketInventoryConfigurationRequest & request,const PutBucketInventoryConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3215 void S3CrtClient::PutBucketInventoryConfigurationAsync(const PutBucketInventoryConfigurationRequest& request, const PutBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3216 {
3217 m_executor->Submit( [this, request, handler, context](){ this->PutBucketInventoryConfigurationAsyncHelper( request, handler, context ); } );
3218 }
3219
PutBucketInventoryConfigurationAsyncHelper(const PutBucketInventoryConfigurationRequest & request,const PutBucketInventoryConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3220 void S3CrtClient::PutBucketInventoryConfigurationAsyncHelper(const PutBucketInventoryConfigurationRequest& request, const PutBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3221 {
3222 handler(this, request, PutBucketInventoryConfiguration(request), context);
3223 }
3224
PutBucketLifecycleConfiguration(const PutBucketLifecycleConfigurationRequest & request) const3225 PutBucketLifecycleConfigurationOutcome S3CrtClient::PutBucketLifecycleConfiguration(const PutBucketLifecycleConfigurationRequest& request) const
3226 {
3227 if (!request.BucketHasBeenSet())
3228 {
3229 AWS_LOGSTREAM_ERROR("PutBucketLifecycleConfiguration", "Required field: Bucket, is not set");
3230 return PutBucketLifecycleConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3231 }
3232 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3233 if (!computeEndpointOutcome.IsSuccess())
3234 {
3235 return PutBucketLifecycleConfigurationOutcome(computeEndpointOutcome.GetError());
3236 }
3237 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3238 Aws::StringStream ss;
3239 ss.str("?lifecycle");
3240 uri.SetQueryString(ss.str());
3241 return PutBucketLifecycleConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3242 }
3243
PutBucketLifecycleConfigurationCallable(const PutBucketLifecycleConfigurationRequest & request) const3244 PutBucketLifecycleConfigurationOutcomeCallable S3CrtClient::PutBucketLifecycleConfigurationCallable(const PutBucketLifecycleConfigurationRequest& request) const
3245 {
3246 auto task = Aws::MakeShared< std::packaged_task< PutBucketLifecycleConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketLifecycleConfiguration(request); } );
3247 auto packagedFunction = [task]() { (*task)(); };
3248 m_executor->Submit(packagedFunction);
3249 return task->get_future();
3250 }
3251
PutBucketLifecycleConfigurationAsync(const PutBucketLifecycleConfigurationRequest & request,const PutBucketLifecycleConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3252 void S3CrtClient::PutBucketLifecycleConfigurationAsync(const PutBucketLifecycleConfigurationRequest& request, const PutBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3253 {
3254 m_executor->Submit( [this, request, handler, context](){ this->PutBucketLifecycleConfigurationAsyncHelper( request, handler, context ); } );
3255 }
3256
PutBucketLifecycleConfigurationAsyncHelper(const PutBucketLifecycleConfigurationRequest & request,const PutBucketLifecycleConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3257 void S3CrtClient::PutBucketLifecycleConfigurationAsyncHelper(const PutBucketLifecycleConfigurationRequest& request, const PutBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3258 {
3259 handler(this, request, PutBucketLifecycleConfiguration(request), context);
3260 }
3261
PutBucketLogging(const PutBucketLoggingRequest & request) const3262 PutBucketLoggingOutcome S3CrtClient::PutBucketLogging(const PutBucketLoggingRequest& request) const
3263 {
3264 if (!request.BucketHasBeenSet())
3265 {
3266 AWS_LOGSTREAM_ERROR("PutBucketLogging", "Required field: Bucket, is not set");
3267 return PutBucketLoggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3268 }
3269 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3270 if (!computeEndpointOutcome.IsSuccess())
3271 {
3272 return PutBucketLoggingOutcome(computeEndpointOutcome.GetError());
3273 }
3274 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3275 Aws::StringStream ss;
3276 ss.str("?logging");
3277 uri.SetQueryString(ss.str());
3278 return PutBucketLoggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3279 }
3280
PutBucketLoggingCallable(const PutBucketLoggingRequest & request) const3281 PutBucketLoggingOutcomeCallable S3CrtClient::PutBucketLoggingCallable(const PutBucketLoggingRequest& request) const
3282 {
3283 auto task = Aws::MakeShared< std::packaged_task< PutBucketLoggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketLogging(request); } );
3284 auto packagedFunction = [task]() { (*task)(); };
3285 m_executor->Submit(packagedFunction);
3286 return task->get_future();
3287 }
3288
PutBucketLoggingAsync(const PutBucketLoggingRequest & request,const PutBucketLoggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3289 void S3CrtClient::PutBucketLoggingAsync(const PutBucketLoggingRequest& request, const PutBucketLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3290 {
3291 m_executor->Submit( [this, request, handler, context](){ this->PutBucketLoggingAsyncHelper( request, handler, context ); } );
3292 }
3293
PutBucketLoggingAsyncHelper(const PutBucketLoggingRequest & request,const PutBucketLoggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3294 void S3CrtClient::PutBucketLoggingAsyncHelper(const PutBucketLoggingRequest& request, const PutBucketLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3295 {
3296 handler(this, request, PutBucketLogging(request), context);
3297 }
3298
PutBucketMetricsConfiguration(const PutBucketMetricsConfigurationRequest & request) const3299 PutBucketMetricsConfigurationOutcome S3CrtClient::PutBucketMetricsConfiguration(const PutBucketMetricsConfigurationRequest& request) const
3300 {
3301 if (!request.BucketHasBeenSet())
3302 {
3303 AWS_LOGSTREAM_ERROR("PutBucketMetricsConfiguration", "Required field: Bucket, is not set");
3304 return PutBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3305 }
3306 if (!request.IdHasBeenSet())
3307 {
3308 AWS_LOGSTREAM_ERROR("PutBucketMetricsConfiguration", "Required field: Id, is not set");
3309 return PutBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
3310 }
3311 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3312 if (!computeEndpointOutcome.IsSuccess())
3313 {
3314 return PutBucketMetricsConfigurationOutcome(computeEndpointOutcome.GetError());
3315 }
3316 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3317 Aws::StringStream ss;
3318 ss.str("?metrics");
3319 uri.SetQueryString(ss.str());
3320 return PutBucketMetricsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3321 }
3322
PutBucketMetricsConfigurationCallable(const PutBucketMetricsConfigurationRequest & request) const3323 PutBucketMetricsConfigurationOutcomeCallable S3CrtClient::PutBucketMetricsConfigurationCallable(const PutBucketMetricsConfigurationRequest& request) const
3324 {
3325 auto task = Aws::MakeShared< std::packaged_task< PutBucketMetricsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketMetricsConfiguration(request); } );
3326 auto packagedFunction = [task]() { (*task)(); };
3327 m_executor->Submit(packagedFunction);
3328 return task->get_future();
3329 }
3330
PutBucketMetricsConfigurationAsync(const PutBucketMetricsConfigurationRequest & request,const PutBucketMetricsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3331 void S3CrtClient::PutBucketMetricsConfigurationAsync(const PutBucketMetricsConfigurationRequest& request, const PutBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3332 {
3333 m_executor->Submit( [this, request, handler, context](){ this->PutBucketMetricsConfigurationAsyncHelper( request, handler, context ); } );
3334 }
3335
PutBucketMetricsConfigurationAsyncHelper(const PutBucketMetricsConfigurationRequest & request,const PutBucketMetricsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3336 void S3CrtClient::PutBucketMetricsConfigurationAsyncHelper(const PutBucketMetricsConfigurationRequest& request, const PutBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3337 {
3338 handler(this, request, PutBucketMetricsConfiguration(request), context);
3339 }
3340
PutBucketNotificationConfiguration(const PutBucketNotificationConfigurationRequest & request) const3341 PutBucketNotificationConfigurationOutcome S3CrtClient::PutBucketNotificationConfiguration(const PutBucketNotificationConfigurationRequest& request) const
3342 {
3343 if (!request.BucketHasBeenSet())
3344 {
3345 AWS_LOGSTREAM_ERROR("PutBucketNotificationConfiguration", "Required field: Bucket, is not set");
3346 return PutBucketNotificationConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3347 }
3348 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3349 if (!computeEndpointOutcome.IsSuccess())
3350 {
3351 return PutBucketNotificationConfigurationOutcome(computeEndpointOutcome.GetError());
3352 }
3353 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3354 Aws::StringStream ss;
3355 ss.str("?notification");
3356 uri.SetQueryString(ss.str());
3357 return PutBucketNotificationConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3358 }
3359
PutBucketNotificationConfigurationCallable(const PutBucketNotificationConfigurationRequest & request) const3360 PutBucketNotificationConfigurationOutcomeCallable S3CrtClient::PutBucketNotificationConfigurationCallable(const PutBucketNotificationConfigurationRequest& request) const
3361 {
3362 auto task = Aws::MakeShared< std::packaged_task< PutBucketNotificationConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketNotificationConfiguration(request); } );
3363 auto packagedFunction = [task]() { (*task)(); };
3364 m_executor->Submit(packagedFunction);
3365 return task->get_future();
3366 }
3367
PutBucketNotificationConfigurationAsync(const PutBucketNotificationConfigurationRequest & request,const PutBucketNotificationConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3368 void S3CrtClient::PutBucketNotificationConfigurationAsync(const PutBucketNotificationConfigurationRequest& request, const PutBucketNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3369 {
3370 m_executor->Submit( [this, request, handler, context](){ this->PutBucketNotificationConfigurationAsyncHelper( request, handler, context ); } );
3371 }
3372
PutBucketNotificationConfigurationAsyncHelper(const PutBucketNotificationConfigurationRequest & request,const PutBucketNotificationConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3373 void S3CrtClient::PutBucketNotificationConfigurationAsyncHelper(const PutBucketNotificationConfigurationRequest& request, const PutBucketNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3374 {
3375 handler(this, request, PutBucketNotificationConfiguration(request), context);
3376 }
3377
PutBucketOwnershipControls(const PutBucketOwnershipControlsRequest & request) const3378 PutBucketOwnershipControlsOutcome S3CrtClient::PutBucketOwnershipControls(const PutBucketOwnershipControlsRequest& request) const
3379 {
3380 if (!request.BucketHasBeenSet())
3381 {
3382 AWS_LOGSTREAM_ERROR("PutBucketOwnershipControls", "Required field: Bucket, is not set");
3383 return PutBucketOwnershipControlsOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3384 }
3385 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3386 if (!computeEndpointOutcome.IsSuccess())
3387 {
3388 return PutBucketOwnershipControlsOutcome(computeEndpointOutcome.GetError());
3389 }
3390 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3391 Aws::StringStream ss;
3392 ss.str("?ownershipControls");
3393 uri.SetQueryString(ss.str());
3394 return PutBucketOwnershipControlsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3395 }
3396
PutBucketOwnershipControlsCallable(const PutBucketOwnershipControlsRequest & request) const3397 PutBucketOwnershipControlsOutcomeCallable S3CrtClient::PutBucketOwnershipControlsCallable(const PutBucketOwnershipControlsRequest& request) const
3398 {
3399 auto task = Aws::MakeShared< std::packaged_task< PutBucketOwnershipControlsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketOwnershipControls(request); } );
3400 auto packagedFunction = [task]() { (*task)(); };
3401 m_executor->Submit(packagedFunction);
3402 return task->get_future();
3403 }
3404
PutBucketOwnershipControlsAsync(const PutBucketOwnershipControlsRequest & request,const PutBucketOwnershipControlsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3405 void S3CrtClient::PutBucketOwnershipControlsAsync(const PutBucketOwnershipControlsRequest& request, const PutBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3406 {
3407 m_executor->Submit( [this, request, handler, context](){ this->PutBucketOwnershipControlsAsyncHelper( request, handler, context ); } );
3408 }
3409
PutBucketOwnershipControlsAsyncHelper(const PutBucketOwnershipControlsRequest & request,const PutBucketOwnershipControlsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3410 void S3CrtClient::PutBucketOwnershipControlsAsyncHelper(const PutBucketOwnershipControlsRequest& request, const PutBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3411 {
3412 handler(this, request, PutBucketOwnershipControls(request), context);
3413 }
3414
PutBucketPolicy(const PutBucketPolicyRequest & request) const3415 PutBucketPolicyOutcome S3CrtClient::PutBucketPolicy(const PutBucketPolicyRequest& request) const
3416 {
3417 if (!request.BucketHasBeenSet())
3418 {
3419 AWS_LOGSTREAM_ERROR("PutBucketPolicy", "Required field: Bucket, is not set");
3420 return PutBucketPolicyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3421 }
3422 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3423 if (!computeEndpointOutcome.IsSuccess())
3424 {
3425 return PutBucketPolicyOutcome(computeEndpointOutcome.GetError());
3426 }
3427 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3428 Aws::StringStream ss;
3429 ss.str("?policy");
3430 uri.SetQueryString(ss.str());
3431 return PutBucketPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3432 }
3433
PutBucketPolicyCallable(const PutBucketPolicyRequest & request) const3434 PutBucketPolicyOutcomeCallable S3CrtClient::PutBucketPolicyCallable(const PutBucketPolicyRequest& request) const
3435 {
3436 auto task = Aws::MakeShared< std::packaged_task< PutBucketPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketPolicy(request); } );
3437 auto packagedFunction = [task]() { (*task)(); };
3438 m_executor->Submit(packagedFunction);
3439 return task->get_future();
3440 }
3441
PutBucketPolicyAsync(const PutBucketPolicyRequest & request,const PutBucketPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3442 void S3CrtClient::PutBucketPolicyAsync(const PutBucketPolicyRequest& request, const PutBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3443 {
3444 m_executor->Submit( [this, request, handler, context](){ this->PutBucketPolicyAsyncHelper( request, handler, context ); } );
3445 }
3446
PutBucketPolicyAsyncHelper(const PutBucketPolicyRequest & request,const PutBucketPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3447 void S3CrtClient::PutBucketPolicyAsyncHelper(const PutBucketPolicyRequest& request, const PutBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3448 {
3449 handler(this, request, PutBucketPolicy(request), context);
3450 }
3451
PutBucketReplication(const PutBucketReplicationRequest & request) const3452 PutBucketReplicationOutcome S3CrtClient::PutBucketReplication(const PutBucketReplicationRequest& request) const
3453 {
3454 if (!request.BucketHasBeenSet())
3455 {
3456 AWS_LOGSTREAM_ERROR("PutBucketReplication", "Required field: Bucket, is not set");
3457 return PutBucketReplicationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3458 }
3459 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3460 if (!computeEndpointOutcome.IsSuccess())
3461 {
3462 return PutBucketReplicationOutcome(computeEndpointOutcome.GetError());
3463 }
3464 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3465 Aws::StringStream ss;
3466 ss.str("?replication");
3467 uri.SetQueryString(ss.str());
3468 return PutBucketReplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3469 }
3470
PutBucketReplicationCallable(const PutBucketReplicationRequest & request) const3471 PutBucketReplicationOutcomeCallable S3CrtClient::PutBucketReplicationCallable(const PutBucketReplicationRequest& request) const
3472 {
3473 auto task = Aws::MakeShared< std::packaged_task< PutBucketReplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketReplication(request); } );
3474 auto packagedFunction = [task]() { (*task)(); };
3475 m_executor->Submit(packagedFunction);
3476 return task->get_future();
3477 }
3478
PutBucketReplicationAsync(const PutBucketReplicationRequest & request,const PutBucketReplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3479 void S3CrtClient::PutBucketReplicationAsync(const PutBucketReplicationRequest& request, const PutBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3480 {
3481 m_executor->Submit( [this, request, handler, context](){ this->PutBucketReplicationAsyncHelper( request, handler, context ); } );
3482 }
3483
PutBucketReplicationAsyncHelper(const PutBucketReplicationRequest & request,const PutBucketReplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3484 void S3CrtClient::PutBucketReplicationAsyncHelper(const PutBucketReplicationRequest& request, const PutBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3485 {
3486 handler(this, request, PutBucketReplication(request), context);
3487 }
3488
PutBucketRequestPayment(const PutBucketRequestPaymentRequest & request) const3489 PutBucketRequestPaymentOutcome S3CrtClient::PutBucketRequestPayment(const PutBucketRequestPaymentRequest& request) const
3490 {
3491 if (!request.BucketHasBeenSet())
3492 {
3493 AWS_LOGSTREAM_ERROR("PutBucketRequestPayment", "Required field: Bucket, is not set");
3494 return PutBucketRequestPaymentOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3495 }
3496 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3497 if (!computeEndpointOutcome.IsSuccess())
3498 {
3499 return PutBucketRequestPaymentOutcome(computeEndpointOutcome.GetError());
3500 }
3501 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3502 Aws::StringStream ss;
3503 ss.str("?requestPayment");
3504 uri.SetQueryString(ss.str());
3505 return PutBucketRequestPaymentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3506 }
3507
PutBucketRequestPaymentCallable(const PutBucketRequestPaymentRequest & request) const3508 PutBucketRequestPaymentOutcomeCallable S3CrtClient::PutBucketRequestPaymentCallable(const PutBucketRequestPaymentRequest& request) const
3509 {
3510 auto task = Aws::MakeShared< std::packaged_task< PutBucketRequestPaymentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketRequestPayment(request); } );
3511 auto packagedFunction = [task]() { (*task)(); };
3512 m_executor->Submit(packagedFunction);
3513 return task->get_future();
3514 }
3515
PutBucketRequestPaymentAsync(const PutBucketRequestPaymentRequest & request,const PutBucketRequestPaymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3516 void S3CrtClient::PutBucketRequestPaymentAsync(const PutBucketRequestPaymentRequest& request, const PutBucketRequestPaymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3517 {
3518 m_executor->Submit( [this, request, handler, context](){ this->PutBucketRequestPaymentAsyncHelper( request, handler, context ); } );
3519 }
3520
PutBucketRequestPaymentAsyncHelper(const PutBucketRequestPaymentRequest & request,const PutBucketRequestPaymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3521 void S3CrtClient::PutBucketRequestPaymentAsyncHelper(const PutBucketRequestPaymentRequest& request, const PutBucketRequestPaymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3522 {
3523 handler(this, request, PutBucketRequestPayment(request), context);
3524 }
3525
PutBucketTagging(const PutBucketTaggingRequest & request) const3526 PutBucketTaggingOutcome S3CrtClient::PutBucketTagging(const PutBucketTaggingRequest& request) const
3527 {
3528 if (!request.BucketHasBeenSet())
3529 {
3530 AWS_LOGSTREAM_ERROR("PutBucketTagging", "Required field: Bucket, is not set");
3531 return PutBucketTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3532 }
3533 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3534 if (!computeEndpointOutcome.IsSuccess())
3535 {
3536 return PutBucketTaggingOutcome(computeEndpointOutcome.GetError());
3537 }
3538 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3539 Aws::StringStream ss;
3540 ss.str("?tagging");
3541 uri.SetQueryString(ss.str());
3542 return PutBucketTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3543 }
3544
PutBucketTaggingCallable(const PutBucketTaggingRequest & request) const3545 PutBucketTaggingOutcomeCallable S3CrtClient::PutBucketTaggingCallable(const PutBucketTaggingRequest& request) const
3546 {
3547 auto task = Aws::MakeShared< std::packaged_task< PutBucketTaggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketTagging(request); } );
3548 auto packagedFunction = [task]() { (*task)(); };
3549 m_executor->Submit(packagedFunction);
3550 return task->get_future();
3551 }
3552
PutBucketTaggingAsync(const PutBucketTaggingRequest & request,const PutBucketTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3553 void S3CrtClient::PutBucketTaggingAsync(const PutBucketTaggingRequest& request, const PutBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3554 {
3555 m_executor->Submit( [this, request, handler, context](){ this->PutBucketTaggingAsyncHelper( request, handler, context ); } );
3556 }
3557
PutBucketTaggingAsyncHelper(const PutBucketTaggingRequest & request,const PutBucketTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3558 void S3CrtClient::PutBucketTaggingAsyncHelper(const PutBucketTaggingRequest& request, const PutBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3559 {
3560 handler(this, request, PutBucketTagging(request), context);
3561 }
3562
PutBucketVersioning(const PutBucketVersioningRequest & request) const3563 PutBucketVersioningOutcome S3CrtClient::PutBucketVersioning(const PutBucketVersioningRequest& request) const
3564 {
3565 if (!request.BucketHasBeenSet())
3566 {
3567 AWS_LOGSTREAM_ERROR("PutBucketVersioning", "Required field: Bucket, is not set");
3568 return PutBucketVersioningOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3569 }
3570 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3571 if (!computeEndpointOutcome.IsSuccess())
3572 {
3573 return PutBucketVersioningOutcome(computeEndpointOutcome.GetError());
3574 }
3575 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3576 Aws::StringStream ss;
3577 ss.str("?versioning");
3578 uri.SetQueryString(ss.str());
3579 return PutBucketVersioningOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3580 }
3581
PutBucketVersioningCallable(const PutBucketVersioningRequest & request) const3582 PutBucketVersioningOutcomeCallable S3CrtClient::PutBucketVersioningCallable(const PutBucketVersioningRequest& request) const
3583 {
3584 auto task = Aws::MakeShared< std::packaged_task< PutBucketVersioningOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketVersioning(request); } );
3585 auto packagedFunction = [task]() { (*task)(); };
3586 m_executor->Submit(packagedFunction);
3587 return task->get_future();
3588 }
3589
PutBucketVersioningAsync(const PutBucketVersioningRequest & request,const PutBucketVersioningResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3590 void S3CrtClient::PutBucketVersioningAsync(const PutBucketVersioningRequest& request, const PutBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3591 {
3592 m_executor->Submit( [this, request, handler, context](){ this->PutBucketVersioningAsyncHelper( request, handler, context ); } );
3593 }
3594
PutBucketVersioningAsyncHelper(const PutBucketVersioningRequest & request,const PutBucketVersioningResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3595 void S3CrtClient::PutBucketVersioningAsyncHelper(const PutBucketVersioningRequest& request, const PutBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3596 {
3597 handler(this, request, PutBucketVersioning(request), context);
3598 }
3599
PutBucketWebsite(const PutBucketWebsiteRequest & request) const3600 PutBucketWebsiteOutcome S3CrtClient::PutBucketWebsite(const PutBucketWebsiteRequest& request) const
3601 {
3602 if (!request.BucketHasBeenSet())
3603 {
3604 AWS_LOGSTREAM_ERROR("PutBucketWebsite", "Required field: Bucket, is not set");
3605 return PutBucketWebsiteOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3606 }
3607 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3608 if (!computeEndpointOutcome.IsSuccess())
3609 {
3610 return PutBucketWebsiteOutcome(computeEndpointOutcome.GetError());
3611 }
3612 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3613 Aws::StringStream ss;
3614 ss.str("?website");
3615 uri.SetQueryString(ss.str());
3616 return PutBucketWebsiteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3617 }
3618
PutBucketWebsiteCallable(const PutBucketWebsiteRequest & request) const3619 PutBucketWebsiteOutcomeCallable S3CrtClient::PutBucketWebsiteCallable(const PutBucketWebsiteRequest& request) const
3620 {
3621 auto task = Aws::MakeShared< std::packaged_task< PutBucketWebsiteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutBucketWebsite(request); } );
3622 auto packagedFunction = [task]() { (*task)(); };
3623 m_executor->Submit(packagedFunction);
3624 return task->get_future();
3625 }
3626
PutBucketWebsiteAsync(const PutBucketWebsiteRequest & request,const PutBucketWebsiteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3627 void S3CrtClient::PutBucketWebsiteAsync(const PutBucketWebsiteRequest& request, const PutBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3628 {
3629 m_executor->Submit( [this, request, handler, context](){ this->PutBucketWebsiteAsyncHelper( request, handler, context ); } );
3630 }
3631
PutBucketWebsiteAsyncHelper(const PutBucketWebsiteRequest & request,const PutBucketWebsiteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3632 void S3CrtClient::PutBucketWebsiteAsyncHelper(const PutBucketWebsiteRequest& request, const PutBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3633 {
3634 handler(this, request, PutBucketWebsite(request), context);
3635 }
3636
PutObjectAcl(const PutObjectAclRequest & request) const3637 PutObjectAclOutcome S3CrtClient::PutObjectAcl(const PutObjectAclRequest& request) const
3638 {
3639 if (!request.BucketHasBeenSet())
3640 {
3641 AWS_LOGSTREAM_ERROR("PutObjectAcl", "Required field: Bucket, is not set");
3642 return PutObjectAclOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3643 }
3644 if (!request.KeyHasBeenSet())
3645 {
3646 AWS_LOGSTREAM_ERROR("PutObjectAcl", "Required field: Key, is not set");
3647 return PutObjectAclOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3648 }
3649 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3650 if (!computeEndpointOutcome.IsSuccess())
3651 {
3652 return PutObjectAclOutcome(computeEndpointOutcome.GetError());
3653 }
3654 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3655 Aws::StringStream ss;
3656 uri.AddPathSegments(request.GetKey());
3657 ss.str("?acl");
3658 uri.SetQueryString(ss.str());
3659 return PutObjectAclOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3660 }
3661
PutObjectAclCallable(const PutObjectAclRequest & request) const3662 PutObjectAclOutcomeCallable S3CrtClient::PutObjectAclCallable(const PutObjectAclRequest& request) const
3663 {
3664 auto task = Aws::MakeShared< std::packaged_task< PutObjectAclOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectAcl(request); } );
3665 auto packagedFunction = [task]() { (*task)(); };
3666 m_executor->Submit(packagedFunction);
3667 return task->get_future();
3668 }
3669
PutObjectAclAsync(const PutObjectAclRequest & request,const PutObjectAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3670 void S3CrtClient::PutObjectAclAsync(const PutObjectAclRequest& request, const PutObjectAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3671 {
3672 m_executor->Submit( [this, request, handler, context](){ this->PutObjectAclAsyncHelper( request, handler, context ); } );
3673 }
3674
PutObjectAclAsyncHelper(const PutObjectAclRequest & request,const PutObjectAclResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3675 void S3CrtClient::PutObjectAclAsyncHelper(const PutObjectAclRequest& request, const PutObjectAclResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3676 {
3677 handler(this, request, PutObjectAcl(request), context);
3678 }
3679
PutObjectLegalHold(const PutObjectLegalHoldRequest & request) const3680 PutObjectLegalHoldOutcome S3CrtClient::PutObjectLegalHold(const PutObjectLegalHoldRequest& request) const
3681 {
3682 if (!request.BucketHasBeenSet())
3683 {
3684 AWS_LOGSTREAM_ERROR("PutObjectLegalHold", "Required field: Bucket, is not set");
3685 return PutObjectLegalHoldOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3686 }
3687 if (!request.KeyHasBeenSet())
3688 {
3689 AWS_LOGSTREAM_ERROR("PutObjectLegalHold", "Required field: Key, is not set");
3690 return PutObjectLegalHoldOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3691 }
3692 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3693 if (!computeEndpointOutcome.IsSuccess())
3694 {
3695 return PutObjectLegalHoldOutcome(computeEndpointOutcome.GetError());
3696 }
3697 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3698 Aws::StringStream ss;
3699 uri.AddPathSegments(request.GetKey());
3700 ss.str("?legal-hold");
3701 uri.SetQueryString(ss.str());
3702 return PutObjectLegalHoldOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3703 }
3704
PutObjectLegalHoldCallable(const PutObjectLegalHoldRequest & request) const3705 PutObjectLegalHoldOutcomeCallable S3CrtClient::PutObjectLegalHoldCallable(const PutObjectLegalHoldRequest& request) const
3706 {
3707 auto task = Aws::MakeShared< std::packaged_task< PutObjectLegalHoldOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectLegalHold(request); } );
3708 auto packagedFunction = [task]() { (*task)(); };
3709 m_executor->Submit(packagedFunction);
3710 return task->get_future();
3711 }
3712
PutObjectLegalHoldAsync(const PutObjectLegalHoldRequest & request,const PutObjectLegalHoldResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3713 void S3CrtClient::PutObjectLegalHoldAsync(const PutObjectLegalHoldRequest& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3714 {
3715 m_executor->Submit( [this, request, handler, context](){ this->PutObjectLegalHoldAsyncHelper( request, handler, context ); } );
3716 }
3717
PutObjectLegalHoldAsyncHelper(const PutObjectLegalHoldRequest & request,const PutObjectLegalHoldResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3718 void S3CrtClient::PutObjectLegalHoldAsyncHelper(const PutObjectLegalHoldRequest& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3719 {
3720 handler(this, request, PutObjectLegalHold(request), context);
3721 }
3722
PutObjectLockConfiguration(const PutObjectLockConfigurationRequest & request) const3723 PutObjectLockConfigurationOutcome S3CrtClient::PutObjectLockConfiguration(const PutObjectLockConfigurationRequest& request) const
3724 {
3725 if (!request.BucketHasBeenSet())
3726 {
3727 AWS_LOGSTREAM_ERROR("PutObjectLockConfiguration", "Required field: Bucket, is not set");
3728 return PutObjectLockConfigurationOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3729 }
3730 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3731 if (!computeEndpointOutcome.IsSuccess())
3732 {
3733 return PutObjectLockConfigurationOutcome(computeEndpointOutcome.GetError());
3734 }
3735 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3736 Aws::StringStream ss;
3737 ss.str("?object-lock");
3738 uri.SetQueryString(ss.str());
3739 return PutObjectLockConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3740 }
3741
PutObjectLockConfigurationCallable(const PutObjectLockConfigurationRequest & request) const3742 PutObjectLockConfigurationOutcomeCallable S3CrtClient::PutObjectLockConfigurationCallable(const PutObjectLockConfigurationRequest& request) const
3743 {
3744 auto task = Aws::MakeShared< std::packaged_task< PutObjectLockConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectLockConfiguration(request); } );
3745 auto packagedFunction = [task]() { (*task)(); };
3746 m_executor->Submit(packagedFunction);
3747 return task->get_future();
3748 }
3749
PutObjectLockConfigurationAsync(const PutObjectLockConfigurationRequest & request,const PutObjectLockConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3750 void S3CrtClient::PutObjectLockConfigurationAsync(const PutObjectLockConfigurationRequest& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3751 {
3752 m_executor->Submit( [this, request, handler, context](){ this->PutObjectLockConfigurationAsyncHelper( request, handler, context ); } );
3753 }
3754
PutObjectLockConfigurationAsyncHelper(const PutObjectLockConfigurationRequest & request,const PutObjectLockConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3755 void S3CrtClient::PutObjectLockConfigurationAsyncHelper(const PutObjectLockConfigurationRequest& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3756 {
3757 handler(this, request, PutObjectLockConfiguration(request), context);
3758 }
3759
PutObjectRetention(const PutObjectRetentionRequest & request) const3760 PutObjectRetentionOutcome S3CrtClient::PutObjectRetention(const PutObjectRetentionRequest& request) const
3761 {
3762 if (!request.BucketHasBeenSet())
3763 {
3764 AWS_LOGSTREAM_ERROR("PutObjectRetention", "Required field: Bucket, is not set");
3765 return PutObjectRetentionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3766 }
3767 if (!request.KeyHasBeenSet())
3768 {
3769 AWS_LOGSTREAM_ERROR("PutObjectRetention", "Required field: Key, is not set");
3770 return PutObjectRetentionOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3771 }
3772 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3773 if (!computeEndpointOutcome.IsSuccess())
3774 {
3775 return PutObjectRetentionOutcome(computeEndpointOutcome.GetError());
3776 }
3777 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3778 Aws::StringStream ss;
3779 uri.AddPathSegments(request.GetKey());
3780 ss.str("?retention");
3781 uri.SetQueryString(ss.str());
3782 return PutObjectRetentionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3783 }
3784
PutObjectRetentionCallable(const PutObjectRetentionRequest & request) const3785 PutObjectRetentionOutcomeCallable S3CrtClient::PutObjectRetentionCallable(const PutObjectRetentionRequest& request) const
3786 {
3787 auto task = Aws::MakeShared< std::packaged_task< PutObjectRetentionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectRetention(request); } );
3788 auto packagedFunction = [task]() { (*task)(); };
3789 m_executor->Submit(packagedFunction);
3790 return task->get_future();
3791 }
3792
PutObjectRetentionAsync(const PutObjectRetentionRequest & request,const PutObjectRetentionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3793 void S3CrtClient::PutObjectRetentionAsync(const PutObjectRetentionRequest& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3794 {
3795 m_executor->Submit( [this, request, handler, context](){ this->PutObjectRetentionAsyncHelper( request, handler, context ); } );
3796 }
3797
PutObjectRetentionAsyncHelper(const PutObjectRetentionRequest & request,const PutObjectRetentionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3798 void S3CrtClient::PutObjectRetentionAsyncHelper(const PutObjectRetentionRequest& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3799 {
3800 handler(this, request, PutObjectRetention(request), context);
3801 }
3802
PutObjectTagging(const PutObjectTaggingRequest & request) const3803 PutObjectTaggingOutcome S3CrtClient::PutObjectTagging(const PutObjectTaggingRequest& request) const
3804 {
3805 if (!request.BucketHasBeenSet())
3806 {
3807 AWS_LOGSTREAM_ERROR("PutObjectTagging", "Required field: Bucket, is not set");
3808 return PutObjectTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3809 }
3810 if (!request.KeyHasBeenSet())
3811 {
3812 AWS_LOGSTREAM_ERROR("PutObjectTagging", "Required field: Key, is not set");
3813 return PutObjectTaggingOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3814 }
3815 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3816 if (!computeEndpointOutcome.IsSuccess())
3817 {
3818 return PutObjectTaggingOutcome(computeEndpointOutcome.GetError());
3819 }
3820 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3821 Aws::StringStream ss;
3822 uri.AddPathSegments(request.GetKey());
3823 ss.str("?tagging");
3824 uri.SetQueryString(ss.str());
3825 return PutObjectTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3826 }
3827
PutObjectTaggingCallable(const PutObjectTaggingRequest & request) const3828 PutObjectTaggingOutcomeCallable S3CrtClient::PutObjectTaggingCallable(const PutObjectTaggingRequest& request) const
3829 {
3830 auto task = Aws::MakeShared< std::packaged_task< PutObjectTaggingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectTagging(request); } );
3831 auto packagedFunction = [task]() { (*task)(); };
3832 m_executor->Submit(packagedFunction);
3833 return task->get_future();
3834 }
3835
PutObjectTaggingAsync(const PutObjectTaggingRequest & request,const PutObjectTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3836 void S3CrtClient::PutObjectTaggingAsync(const PutObjectTaggingRequest& request, const PutObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3837 {
3838 m_executor->Submit( [this, request, handler, context](){ this->PutObjectTaggingAsyncHelper( request, handler, context ); } );
3839 }
3840
PutObjectTaggingAsyncHelper(const PutObjectTaggingRequest & request,const PutObjectTaggingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3841 void S3CrtClient::PutObjectTaggingAsyncHelper(const PutObjectTaggingRequest& request, const PutObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3842 {
3843 handler(this, request, PutObjectTagging(request), context);
3844 }
3845
PutPublicAccessBlock(const PutPublicAccessBlockRequest & request) const3846 PutPublicAccessBlockOutcome S3CrtClient::PutPublicAccessBlock(const PutPublicAccessBlockRequest& request) const
3847 {
3848 if (!request.BucketHasBeenSet())
3849 {
3850 AWS_LOGSTREAM_ERROR("PutPublicAccessBlock", "Required field: Bucket, is not set");
3851 return PutPublicAccessBlockOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3852 }
3853 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3854 if (!computeEndpointOutcome.IsSuccess())
3855 {
3856 return PutPublicAccessBlockOutcome(computeEndpointOutcome.GetError());
3857 }
3858 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3859 Aws::StringStream ss;
3860 ss.str("?publicAccessBlock");
3861 uri.SetQueryString(ss.str());
3862 return PutPublicAccessBlockOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3863 }
3864
PutPublicAccessBlockCallable(const PutPublicAccessBlockRequest & request) const3865 PutPublicAccessBlockOutcomeCallable S3CrtClient::PutPublicAccessBlockCallable(const PutPublicAccessBlockRequest& request) const
3866 {
3867 auto task = Aws::MakeShared< std::packaged_task< PutPublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutPublicAccessBlock(request); } );
3868 auto packagedFunction = [task]() { (*task)(); };
3869 m_executor->Submit(packagedFunction);
3870 return task->get_future();
3871 }
3872
PutPublicAccessBlockAsync(const PutPublicAccessBlockRequest & request,const PutPublicAccessBlockResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3873 void S3CrtClient::PutPublicAccessBlockAsync(const PutPublicAccessBlockRequest& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3874 {
3875 m_executor->Submit( [this, request, handler, context](){ this->PutPublicAccessBlockAsyncHelper( request, handler, context ); } );
3876 }
3877
PutPublicAccessBlockAsyncHelper(const PutPublicAccessBlockRequest & request,const PutPublicAccessBlockResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3878 void S3CrtClient::PutPublicAccessBlockAsyncHelper(const PutPublicAccessBlockRequest& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3879 {
3880 handler(this, request, PutPublicAccessBlock(request), context);
3881 }
3882
RestoreObject(const RestoreObjectRequest & request) const3883 RestoreObjectOutcome S3CrtClient::RestoreObject(const RestoreObjectRequest& request) const
3884 {
3885 if (!request.BucketHasBeenSet())
3886 {
3887 AWS_LOGSTREAM_ERROR("RestoreObject", "Required field: Bucket, is not set");
3888 return RestoreObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3889 }
3890 if (!request.KeyHasBeenSet())
3891 {
3892 AWS_LOGSTREAM_ERROR("RestoreObject", "Required field: Key, is not set");
3893 return RestoreObjectOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3894 }
3895 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3896 if (!computeEndpointOutcome.IsSuccess())
3897 {
3898 return RestoreObjectOutcome(computeEndpointOutcome.GetError());
3899 }
3900 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3901 Aws::StringStream ss;
3902 uri.AddPathSegments(request.GetKey());
3903 ss.str("?restore");
3904 uri.SetQueryString(ss.str());
3905 return RestoreObjectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3906 }
3907
RestoreObjectCallable(const RestoreObjectRequest & request) const3908 RestoreObjectOutcomeCallable S3CrtClient::RestoreObjectCallable(const RestoreObjectRequest& request) const
3909 {
3910 auto task = Aws::MakeShared< std::packaged_task< RestoreObjectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RestoreObject(request); } );
3911 auto packagedFunction = [task]() { (*task)(); };
3912 m_executor->Submit(packagedFunction);
3913 return task->get_future();
3914 }
3915
RestoreObjectAsync(const RestoreObjectRequest & request,const RestoreObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3916 void S3CrtClient::RestoreObjectAsync(const RestoreObjectRequest& request, const RestoreObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3917 {
3918 m_executor->Submit( [this, request, handler, context](){ this->RestoreObjectAsyncHelper( request, handler, context ); } );
3919 }
3920
RestoreObjectAsyncHelper(const RestoreObjectRequest & request,const RestoreObjectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3921 void S3CrtClient::RestoreObjectAsyncHelper(const RestoreObjectRequest& request, const RestoreObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3922 {
3923 handler(this, request, RestoreObject(request), context);
3924 }
3925
SelectObjectContent(SelectObjectContentRequest & request) const3926 SelectObjectContentOutcome S3CrtClient::SelectObjectContent(SelectObjectContentRequest& request) const
3927 {
3928 if (!request.BucketHasBeenSet())
3929 {
3930 AWS_LOGSTREAM_ERROR("SelectObjectContent", "Required field: Bucket, is not set");
3931 return SelectObjectContentOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3932 }
3933 if (!request.KeyHasBeenSet())
3934 {
3935 AWS_LOGSTREAM_ERROR("SelectObjectContent", "Required field: Key, is not set");
3936 return SelectObjectContentOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3937 }
3938 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3939 if (!computeEndpointOutcome.IsSuccess())
3940 {
3941 return SelectObjectContentOutcome(computeEndpointOutcome.GetError());
3942 }
3943 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
3944 Aws::StringStream ss;
3945 uri.AddPathSegments(request.GetKey());
3946 ss.str("?select&select-type=2");
3947 uri.SetQueryString(ss.str());
3948 request.SetResponseStreamFactory(
3949 [&] { request.GetEventStreamDecoder().Reset(); return Aws::New<Aws::Utils::Event::EventDecoderStream>(ALLOCATION_TAG, request.GetEventStreamDecoder()); }
3950 );
3951 return SelectObjectContentOutcome(MakeRequestWithEventStream(uri, request, Aws::Http::HttpMethod::HTTP_POST, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
3952 }
3953
SelectObjectContentCallable(SelectObjectContentRequest & request) const3954 SelectObjectContentOutcomeCallable S3CrtClient::SelectObjectContentCallable(SelectObjectContentRequest& request) const
3955 {
3956 auto task = Aws::MakeShared< std::packaged_task< SelectObjectContentOutcome() > >(ALLOCATION_TAG, [this, &request](){ return this->SelectObjectContent(request); } );
3957 auto packagedFunction = [task]() { (*task)(); };
3958 m_executor->Submit(packagedFunction);
3959 return task->get_future();
3960 }
3961
SelectObjectContentAsync(SelectObjectContentRequest & request,const SelectObjectContentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3962 void S3CrtClient::SelectObjectContentAsync(SelectObjectContentRequest& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3963 {
3964 m_executor->Submit( [this, &request, handler, context](){ this->SelectObjectContentAsyncHelper( request, handler, context ); } );
3965 }
3966
SelectObjectContentAsyncHelper(SelectObjectContentRequest & request,const SelectObjectContentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3967 void S3CrtClient::SelectObjectContentAsyncHelper(SelectObjectContentRequest& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3968 {
3969 handler(this, request, SelectObjectContent(request), context);
3970 }
3971
UploadPart(const UploadPartRequest & request) const3972 UploadPartOutcome S3CrtClient::UploadPart(const UploadPartRequest& request) const
3973 {
3974 if (!request.BucketHasBeenSet())
3975 {
3976 AWS_LOGSTREAM_ERROR("UploadPart", "Required field: Bucket, is not set");
3977 return UploadPartOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
3978 }
3979 if (!request.KeyHasBeenSet())
3980 {
3981 AWS_LOGSTREAM_ERROR("UploadPart", "Required field: Key, is not set");
3982 return UploadPartOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
3983 }
3984 if (!request.PartNumberHasBeenSet())
3985 {
3986 AWS_LOGSTREAM_ERROR("UploadPart", "Required field: PartNumber, is not set");
3987 return UploadPartOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PartNumber]", false));
3988 }
3989 if (!request.UploadIdHasBeenSet())
3990 {
3991 AWS_LOGSTREAM_ERROR("UploadPart", "Required field: UploadId, is not set");
3992 return UploadPartOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
3993 }
3994 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
3995 if (!computeEndpointOutcome.IsSuccess())
3996 {
3997 return UploadPartOutcome(computeEndpointOutcome.GetError());
3998 }
3999 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
4000 uri.AddPathSegments(request.GetKey());
4001 return UploadPartOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
4002 }
4003
UploadPartCallable(const UploadPartRequest & request) const4004 UploadPartOutcomeCallable S3CrtClient::UploadPartCallable(const UploadPartRequest& request) const
4005 {
4006 auto task = Aws::MakeShared< std::packaged_task< UploadPartOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UploadPart(request); } );
4007 auto packagedFunction = [task]() { (*task)(); };
4008 m_executor->Submit(packagedFunction);
4009 return task->get_future();
4010 }
4011
UploadPartAsync(const UploadPartRequest & request,const UploadPartResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4012 void S3CrtClient::UploadPartAsync(const UploadPartRequest& request, const UploadPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4013 {
4014 m_executor->Submit( [this, request, handler, context](){ this->UploadPartAsyncHelper( request, handler, context ); } );
4015 }
4016
UploadPartAsyncHelper(const UploadPartRequest & request,const UploadPartResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4017 void S3CrtClient::UploadPartAsyncHelper(const UploadPartRequest& request, const UploadPartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4018 {
4019 handler(this, request, UploadPart(request), context);
4020 }
4021
UploadPartCopy(const UploadPartCopyRequest & request) const4022 UploadPartCopyOutcome S3CrtClient::UploadPartCopy(const UploadPartCopyRequest& request) const
4023 {
4024 if (!request.BucketHasBeenSet())
4025 {
4026 AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: Bucket, is not set");
4027 return UploadPartCopyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
4028 }
4029 if (!request.CopySourceHasBeenSet())
4030 {
4031 AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: CopySource, is not set");
4032 return UploadPartCopyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CopySource]", false));
4033 }
4034 if (!request.KeyHasBeenSet())
4035 {
4036 AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: Key, is not set");
4037 return UploadPartCopyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
4038 }
4039 if (!request.PartNumberHasBeenSet())
4040 {
4041 AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: PartNumber, is not set");
4042 return UploadPartCopyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PartNumber]", false));
4043 }
4044 if (!request.UploadIdHasBeenSet())
4045 {
4046 AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: UploadId, is not set");
4047 return UploadPartCopyOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
4048 }
4049 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
4050 if (!computeEndpointOutcome.IsSuccess())
4051 {
4052 return UploadPartCopyOutcome(computeEndpointOutcome.GetError());
4053 }
4054 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
4055 uri.AddPathSegments(request.GetKey());
4056 return UploadPartCopyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
4057 }
4058
UploadPartCopyCallable(const UploadPartCopyRequest & request) const4059 UploadPartCopyOutcomeCallable S3CrtClient::UploadPartCopyCallable(const UploadPartCopyRequest& request) const
4060 {
4061 auto task = Aws::MakeShared< std::packaged_task< UploadPartCopyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UploadPartCopy(request); } );
4062 auto packagedFunction = [task]() { (*task)(); };
4063 m_executor->Submit(packagedFunction);
4064 return task->get_future();
4065 }
4066
UploadPartCopyAsync(const UploadPartCopyRequest & request,const UploadPartCopyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4067 void S3CrtClient::UploadPartCopyAsync(const UploadPartCopyRequest& request, const UploadPartCopyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4068 {
4069 m_executor->Submit( [this, request, handler, context](){ this->UploadPartCopyAsyncHelper( request, handler, context ); } );
4070 }
4071
UploadPartCopyAsyncHelper(const UploadPartCopyRequest & request,const UploadPartCopyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4072 void S3CrtClient::UploadPartCopyAsyncHelper(const UploadPartCopyRequest& request, const UploadPartCopyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4073 {
4074 handler(this, request, UploadPartCopy(request), context);
4075 }
4076
WriteGetObjectResponse(const WriteGetObjectResponseRequest & request) const4077 WriteGetObjectResponseOutcome S3CrtClient::WriteGetObjectResponse(const WriteGetObjectResponseRequest& request) const
4078 {
4079 if (!request.RequestRouteHasBeenSet())
4080 {
4081 AWS_LOGSTREAM_ERROR("WriteGetObjectResponse", "Required field: RequestRoute, is not set");
4082 return WriteGetObjectResponseOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RequestRoute]", false));
4083 }
4084 if (!request.RequestTokenHasBeenSet())
4085 {
4086 AWS_LOGSTREAM_ERROR("WriteGetObjectResponse", "Required field: RequestToken, is not set");
4087 return WriteGetObjectResponseOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RequestToken]", false));
4088 }
4089 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointStringWithServiceName("s3-object-lambda");
4090 if (!computeEndpointOutcome.IsSuccess())
4091 {
4092 return WriteGetObjectResponseOutcome(computeEndpointOutcome.GetError());
4093 }
4094 Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
4095 if (m_enableHostPrefixInjection)
4096 {
4097 if (request.GetRequestRoute().empty())
4098 {
4099 AWS_LOGSTREAM_ERROR("WriteGetObjectResponse", "HostPrefix required field: RequestRoute, is empty");
4100 return WriteGetObjectResponseOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host prefix field is empty", false));
4101 }
4102 uri.SetAuthority("" + request.GetRequestRoute() + "." + uri.GetAuthority());
4103 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4104 {
4105 AWS_LOGSTREAM_ERROR("WriteGetObjectResponse", "Invalid DNS host: " << uri.GetAuthority());
4106 return WriteGetObjectResponseOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4107 }
4108 }
4109 uri.AddPathSegments("/WriteGetObjectResponse");
4110 return WriteGetObjectResponseOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, computeEndpointOutcome.GetResult().signerName.c_str() /*signerName*/, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
4111 }
4112
WriteGetObjectResponseCallable(const WriteGetObjectResponseRequest & request) const4113 WriteGetObjectResponseOutcomeCallable S3CrtClient::WriteGetObjectResponseCallable(const WriteGetObjectResponseRequest& request) const
4114 {
4115 auto task = Aws::MakeShared< std::packaged_task< WriteGetObjectResponseOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->WriteGetObjectResponse(request); } );
4116 auto packagedFunction = [task]() { (*task)(); };
4117 m_executor->Submit(packagedFunction);
4118 return task->get_future();
4119 }
4120
WriteGetObjectResponseAsync(const WriteGetObjectResponseRequest & request,const WriteGetObjectResponseResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4121 void S3CrtClient::WriteGetObjectResponseAsync(const WriteGetObjectResponseRequest& request, const WriteGetObjectResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4122 {
4123 m_executor->Submit( [this, request, handler, context](){ this->WriteGetObjectResponseAsyncHelper( request, handler, context ); } );
4124 }
4125
WriteGetObjectResponseAsyncHelper(const WriteGetObjectResponseRequest & request,const WriteGetObjectResponseResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4126 void S3CrtClient::WriteGetObjectResponseAsyncHelper(const WriteGetObjectResponseRequest& request, const WriteGetObjectResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4127 {
4128 handler(this, request, WriteGetObjectResponse(request), context);
4129 }
4130
4131
4132 static const char US_EAST_1_REGIONAL_ENDPOINT_ENV_VAR[] = "AWS_S3_US_EAST_1_REGIONAL_ENDPOINT";
4133 static const char US_EAST_1_REGIONAL_ENDPOINT_CONFIG_VAR[] = "s3_us_east_1_regional_endpoint";
4134 static const char S3_USE_ARN_REGION_ENVIRONMENT_VARIABLE[] = "AWS_S3_USE_ARN_REGION";
4135 static const char S3_USE_ARN_REGION_CONFIG_FILE_OPTION[] = "s3_use_arn_region";
4136 static const char S3_DISABLE_MULTIREGION_ACCESS_POINTS_ENV_VAR[] = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
4137 static const char S3_DISABLE_MULTIREGION_ACCESS_POINTS_CONFIG_VAR[] = "s3_disable_multiregion_access_points";
4138
LoadS3CrtSpecificConfig(const Aws::String & profile)4139 void S3CrtClient::LoadS3CrtSpecificConfig(const Aws::String& profile)
4140 {
4141 if (m_USEast1RegionalEndpointOption == Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET)
4142 {
4143 Aws::String option = Aws::Environment::GetEnv(US_EAST_1_REGIONAL_ENDPOINT_ENV_VAR);
4144 if (option.empty())
4145 {
4146 option = Aws::Config::GetCachedConfigValue(profile, US_EAST_1_REGIONAL_ENDPOINT_CONFIG_VAR);
4147 }
4148
4149 if (Aws::Utils::StringUtils::ToLower(option.c_str()) == "legacy")
4150 {
4151 m_USEast1RegionalEndpointOption = Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::LEGACY;
4152 }
4153 else // defaults is regional
4154 {
4155 m_USEast1RegionalEndpointOption = Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::REGIONAL;
4156 }
4157 }
4158
4159 Aws::String s3UseArnRegion = Aws::Environment::GetEnv(S3_USE_ARN_REGION_ENVIRONMENT_VARIABLE);
4160 if (s3UseArnRegion.empty())
4161 {
4162 s3UseArnRegion = Aws::Config::GetCachedConfigValue(profile, S3_USE_ARN_REGION_CONFIG_FILE_OPTION);
4163 }
4164
4165 if (s3UseArnRegion == "true")
4166 {
4167 m_useArnRegion = true;
4168 }
4169 else
4170 {
4171 if (!s3UseArnRegion.empty() && s3UseArnRegion != "false")
4172 {
4173 AWS_LOGSTREAM_WARN("S3CrtClient", "AWS_S3_USE_ARN_REGION in environment variables or s3_use_arn_region in config file"
4174 << "should either be true of false if specified, otherwise turn off this flag by default.");
4175 }
4176 m_useArnRegion = false;
4177 }
4178
4179 Aws::String s3DisableMultiRegionAccessPoints = Aws::Environment::GetEnv(S3_DISABLE_MULTIREGION_ACCESS_POINTS_ENV_VAR);
4180 if (s3DisableMultiRegionAccessPoints.empty())
4181 {
4182 s3DisableMultiRegionAccessPoints = Aws::Config::GetCachedConfigValue(profile, S3_DISABLE_MULTIREGION_ACCESS_POINTS_CONFIG_VAR);
4183 }
4184 if (s3DisableMultiRegionAccessPoints == "true")
4185 {
4186 m_disableMultiRegionAccessPoints = true;
4187 }
4188 else
4189 {
4190 if (!s3DisableMultiRegionAccessPoints.empty() && s3DisableMultiRegionAccessPoints != "false")
4191 {
4192 AWS_LOGSTREAM_WARN("S3CrtClient", "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS in environment variables or s3_disable_multiregion_access_points"
4193 << "in config file should either be true of false if specified, otherwise turn off this flag by default.");
4194 }
4195 m_disableMultiRegionAccessPoints = false;
4196 }
4197 }
4198
4199 #include<aws/core/utils/HashingUtils.h>
GeneratePresignedUrl(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,long long expirationInSeconds)4200 Aws::String S3CrtClient::GeneratePresignedUrl(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, long long expirationInSeconds)
4201 {
4202 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4203 if (!computeEndpointOutcome.IsSuccess())
4204 {
4205 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4206 return {};
4207 }
4208 URI uri(computeEndpointOutcome.GetResult().endpoint);
4209 uri.SetPath(uri.GetPath() + "/" + key);
4210 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4211 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), expirationInSeconds);
4212 }
4213
GeneratePresignedUrl(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,const Http::HeaderValueCollection & customizedHeaders,long long expirationInSeconds)4214 Aws::String S3CrtClient::GeneratePresignedUrl(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, const Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds)
4215 {
4216 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4217 if (!computeEndpointOutcome.IsSuccess())
4218 {
4219 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4220 return {};
4221 }
4222 URI uri(computeEndpointOutcome.GetResult().endpoint);
4223 uri.SetPath(uri.GetPath() + "/" + key);
4224 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4225 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), customizedHeaders, expirationInSeconds);
4226 }
4227
GeneratePresignedUrlWithSSES3(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,long long expirationInSeconds)4228 Aws::String S3CrtClient::GeneratePresignedUrlWithSSES3(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, long long expirationInSeconds)
4229 {
4230 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4231 if (!computeEndpointOutcome.IsSuccess())
4232 {
4233 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4234 return {};
4235 }
4236 URI uri(computeEndpointOutcome.GetResult().endpoint);
4237 uri.SetPath(uri.GetPath() + "/" + key);
4238 Aws::Http::HeaderValueCollection headers;
4239 headers.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION, Aws::S3Crt::Model::ServerSideEncryptionMapper::GetNameForServerSideEncryption(Aws::S3Crt::Model::ServerSideEncryption::AES256));
4240 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4241 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), headers, expirationInSeconds);
4242 }
4243
GeneratePresignedUrlWithSSES3(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,Http::HeaderValueCollection customizedHeaders,long long expirationInSeconds)4244 Aws::String S3CrtClient::GeneratePresignedUrlWithSSES3(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, Http::HeaderValueCollection customizedHeaders, long long expirationInSeconds)
4245 {
4246 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4247 if (!computeEndpointOutcome.IsSuccess())
4248 {
4249 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4250 return {};
4251 }
4252 URI uri(computeEndpointOutcome.GetResult().endpoint);
4253 uri.SetPath(uri.GetPath() + "/" + key);
4254 customizedHeaders.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION, Aws::S3Crt::Model::ServerSideEncryptionMapper::GetNameForServerSideEncryption(Aws::S3Crt::Model::ServerSideEncryption::AES256));
4255 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4256 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), customizedHeaders, expirationInSeconds);
4257 }
4258
GeneratePresignedUrlWithSSEKMS(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,const Aws::String & kmsMasterKeyId,long long expirationInSeconds)4259 Aws::String S3CrtClient::GeneratePresignedUrlWithSSEKMS(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, const Aws::String& kmsMasterKeyId, long long expirationInSeconds)
4260 {
4261 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4262 if (!computeEndpointOutcome.IsSuccess())
4263 {
4264 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4265 return {};
4266 }
4267 URI uri(computeEndpointOutcome.GetResult().endpoint);
4268 uri.SetPath(uri.GetPath() + "/" + key);
4269 Aws::Http::HeaderValueCollection headers;
4270 headers.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION, Aws::S3Crt::Model::ServerSideEncryptionMapper::GetNameForServerSideEncryption(Aws::S3Crt::Model::ServerSideEncryption::aws_kms));
4271 headers.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID, kmsMasterKeyId);
4272 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4273 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), headers, expirationInSeconds);
4274 }
4275
GeneratePresignedUrlWithSSEKMS(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,Http::HeaderValueCollection customizedHeaders,const Aws::String & kmsMasterKeyId,long long expirationInSeconds)4276 Aws::String S3CrtClient::GeneratePresignedUrlWithSSEKMS(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, Http::HeaderValueCollection customizedHeaders, const Aws::String& kmsMasterKeyId, long long expirationInSeconds)
4277 {
4278 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4279 if (!computeEndpointOutcome.IsSuccess())
4280 {
4281 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4282 return {};
4283 }
4284 URI uri(computeEndpointOutcome.GetResult().endpoint);
4285 uri.SetPath(uri.GetPath() + "/" + key);
4286 customizedHeaders.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION, Aws::S3Crt::Model::ServerSideEncryptionMapper::GetNameForServerSideEncryption(Aws::S3Crt::Model::ServerSideEncryption::aws_kms));
4287 customizedHeaders.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID, kmsMasterKeyId);
4288 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4289 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), customizedHeaders, expirationInSeconds);
4290 }
4291
GeneratePresignedUrlWithSSEC(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,const Aws::String & base64EncodedAES256Key,long long expirationInSeconds)4292 Aws::String S3CrtClient::GeneratePresignedUrlWithSSEC(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, const Aws::String& base64EncodedAES256Key, long long expirationInSeconds)
4293 {
4294 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4295 if (!computeEndpointOutcome.IsSuccess())
4296 {
4297 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4298 return {};
4299 }
4300 URI uri(computeEndpointOutcome.GetResult().endpoint);
4301 uri.SetPath(uri.GetPath() + "/" + key);
4302 Aws::Http::HeaderValueCollection headers;
4303 headers.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM, Aws::S3Crt::Model::ServerSideEncryptionMapper::GetNameForServerSideEncryption(Aws::S3Crt::Model::ServerSideEncryption::AES256));
4304 headers.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY, base64EncodedAES256Key);
4305 Aws::Utils::ByteBuffer buffer = Aws::Utils::HashingUtils::Base64Decode(base64EncodedAES256Key);
4306 Aws::String strBuffer(reinterpret_cast<char*>(buffer.GetUnderlyingData()), buffer.GetLength());
4307 headers.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5, Aws::Utils::HashingUtils::Base64Encode(Aws::Utils::HashingUtils::CalculateMD5(strBuffer)));
4308 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4309 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), headers, expirationInSeconds);
4310 }
4311
GeneratePresignedUrlWithSSEC(const Aws::String & bucket,const Aws::String & key,Aws::Http::HttpMethod method,Http::HeaderValueCollection customizedHeaders,const Aws::String & base64EncodedAES256Key,long long expirationInSeconds)4312 Aws::String S3CrtClient::GeneratePresignedUrlWithSSEC(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, Http::HeaderValueCollection customizedHeaders, const Aws::String& base64EncodedAES256Key, long long expirationInSeconds)
4313 {
4314 ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(bucket);
4315 if (!computeEndpointOutcome.IsSuccess())
4316 {
4317 AWS_LOGSTREAM_ERROR(ALLOCATION_TAG, "Presigned URL generating failed. Encountered error: " << computeEndpointOutcome.GetError());
4318 return {};
4319 }
4320 URI uri(computeEndpointOutcome.GetResult().endpoint);
4321 uri.SetPath(uri.GetPath() + "/" + key);
4322 customizedHeaders.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM, Aws::S3Crt::Model::ServerSideEncryptionMapper::GetNameForServerSideEncryption(Aws::S3Crt::Model::ServerSideEncryption::AES256));
4323 customizedHeaders.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY, base64EncodedAES256Key);
4324 Aws::Utils::ByteBuffer buffer = Aws::Utils::HashingUtils::Base64Decode(base64EncodedAES256Key);
4325 Aws::String strBuffer(reinterpret_cast<char*>(buffer.GetUnderlyingData()), buffer.GetLength());
4326 customizedHeaders.emplace(Aws::S3Crt::SSEHeaders::SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5, Aws::Utils::HashingUtils::Base64Encode(Aws::Utils::HashingUtils::CalculateMD5(strBuffer)));
4327 return AWSClient::GeneratePresignedUrl(uri, method, computeEndpointOutcome.GetResult().signerRegion.c_str(),
4328 computeEndpointOutcome.GetResult().signerServiceName.c_str(), computeEndpointOutcome.GetResult().signerName.c_str(), customizedHeaders, expirationInSeconds);
4329 }
4330
ComputeEndpointString(const Aws::String & bucketOrArn) const4331 ComputeEndpointOutcome S3CrtClient::ComputeEndpointString(const Aws::String& bucketOrArn) const
4332 {
4333 if (m_useDualStack && m_useCustomEndpoint)
4334 {
4335 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4336 "Dual-stack endpoint is incompatible with a custom endpoint override.", false));
4337 }
4338
4339 Aws::StringStream ss;
4340 ss << m_scheme << "://";
4341 Aws::String bucket = bucketOrArn;
4342 Aws::String signerRegion = Aws::Region::ComputeSignerRegion(m_region);
4343 S3CrtARN arn(bucketOrArn);
4344
4345 if (arn)
4346 {
4347 if (!m_useVirtualAddressing)
4348 {
4349 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4350 "Path style addressing is not compatible with Access Point ARN or Outposts ARN in Bucket field, please consider using virtual addressing for this client instead.", false));
4351 }
4352
4353 bool useClientRegion = !m_useArnRegion || Aws::Region::IsFipsRegion(m_region);
4354 S3CrtARNOutcome s3ArnOutcome = useClientRegion ? arn.Validate(m_region.c_str()) : arn.Validate();
4355 if (!s3ArnOutcome.IsSuccess())
4356 {
4357 return ComputeEndpointOutcome(s3ArnOutcome.GetError());
4358 }
4359 signerRegion = m_useArnRegion ? arn.GetRegion() : signerRegion;
4360 // S3 Object Lambda Access Point ARN
4361 if (arn.GetService() == ARNService::S3_OBJECT_LAMBDA)
4362 {
4363 if (m_useDualStack)
4364 {
4365 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4366 "S3 Object Lambda Access Point ARNs do not support dualstack right now.", false));
4367 }
4368 ss << S3CrtEndpoint::ForObjectLambdaAccessPointArn(arn, useClientRegion ? m_region : "", m_useDualStack, m_useCustomEndpoint ? m_baseUri : "");
4369 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), signerRegion, ARNService::S3_OBJECT_LAMBDA));
4370 }
4371 // S3 Multi Region Access Point ARN
4372 else if (arn.GetResourceType() == ARNResourceType::ACCESSPOINT && arn.GetRegion().empty())
4373 {
4374 if (m_disableMultiRegionAccessPoints)
4375 {
4376 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4377 "Multi Region Access Point ARN is disabled explicitly. Unset AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS in environment variables and s3_disable_multiregion_access_points in config file, or set them to false.", false));
4378 }
4379 if (m_useDualStack)
4380 {
4381 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4382 "S3 Multi Region Access Point ARNs do not support dualstack right now.", false));
4383 }
4384 if (m_useCustomEndpoint)
4385 {
4386 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4387 "S3 Multi Region Access Point ARNs do not support custom endpoint override right now.", false));
4388 }
4389 ss << S3CrtEndpoint::ForMultiRegionAccessPointArn(arn, m_useDualStack, m_useCustomEndpoint ? m_baseUri : "");
4390 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), "*", SERVICE_NAME, Aws::Auth::ASYMMETRIC_SIGV4_SIGNER));
4391 }
4392 // Regular S3 Access Point ARN
4393 else if (arn.GetResourceType() == ARNResourceType::ACCESSPOINT)
4394 {
4395 ss << S3CrtEndpoint::ForAccessPointArn(arn, useClientRegion ? m_region : "", m_useDualStack, m_useCustomEndpoint ? m_baseUri : "");
4396 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), signerRegion, SERVICE_NAME));
4397 }
4398 // S3 Outposts Access Point ARN
4399 else if (arn.GetResourceType() == ARNResourceType::OUTPOST)
4400 {
4401 if (m_useDualStack)
4402 {
4403 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4404 "Outposts Access Points do not support dualstack right now.", false));
4405 }
4406 ss << S3CrtEndpoint::ForOutpostsArn(arn, useClientRegion ? m_region : "", m_useDualStack, m_useCustomEndpoint ? m_baseUri : "");
4407 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), signerRegion, ARNService::S3_OUTPOSTS));
4408 }
4409 }
4410
4411 // when using virtual hosting of buckets, the bucket name has to follow some rules.
4412 // Mainly, it has to be a valid DNS label, and it must be lowercase.
4413 // For more information see http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html#VirtualHostingSpecifyBucket
4414 if(m_useVirtualAddressing && Aws::Utils::IsValidDnsLabel(bucket) &&
4415 bucket == Aws::Utils::StringUtils::ToLower(bucket.c_str()))
4416 {
4417 ss << bucket << "." << m_baseUri;
4418 }
4419 else
4420 {
4421 ss << m_baseUri << "/" << bucket;
4422 }
4423
4424 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), signerRegion, SERVICE_NAME));
4425 }
4426
ComputeEndpointString() const4427 ComputeEndpointOutcome S3CrtClient::ComputeEndpointString() const
4428 {
4429 if (m_useDualStack && m_useCustomEndpoint)
4430 {
4431 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4432 "Dual-stack endpoint is incompatible with a custom endpoint override.", false));
4433 }
4434 Aws::StringStream ss;
4435 ss << m_scheme << "://" << m_baseUri;
4436 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), Aws::Region::ComputeSignerRegion(m_region), SERVICE_NAME));
4437 }
4438
ComputeEndpointStringWithServiceName(const Aws::String & serviceNameOverride) const4439 ComputeEndpointOutcome S3CrtClient::ComputeEndpointStringWithServiceName(const Aws::String& serviceNameOverride) const
4440 {
4441 if (serviceNameOverride.empty())
4442 {
4443 return ComputeEndpointString();
4444 }
4445
4446 if (m_useDualStack && m_useCustomEndpoint)
4447 {
4448 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4449 "Dual-stack endpoint is incompatible with a custom endpoint override.", false));
4450 }
4451
4452 Aws::StringStream ss;
4453 ss << m_scheme << "://";
4454 if (m_useCustomEndpoint)
4455 {
4456 ss << m_baseUri;
4457 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), Aws::Region::ComputeSignerRegion(m_region), serviceNameOverride));
4458 }
4459 else
4460 {
4461 if (m_useDualStack)
4462 {
4463 return ComputeEndpointOutcome(Aws::Client::AWSError<S3CrtErrors>(S3CrtErrors::VALIDATION, "VALIDATION",
4464 "S3 Object Lambda endpoints do not support dualstack right now.", false));
4465 }
4466 else
4467 {
4468 ss << S3CrtEndpoint::ForRegion(m_region, m_useDualStack, true, serviceNameOverride);
4469 return ComputeEndpointOutcome(ComputeEndpointResult(ss.str(), Aws::Region::ComputeSignerRegion(m_region), serviceNameOverride));
4470 }
4471 }
4472 }
4473
MultipartUploadSupported() const4474 bool S3CrtClient::MultipartUploadSupported() const
4475 {
4476 return true;
4477 }
4478