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/json/JsonSerializer.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
20 #include <aws/ecs/ECSClient.h>
21 #include <aws/ecs/ECSEndpoint.h>
22 #include <aws/ecs/ECSErrorMarshaller.h>
23 #include <aws/ecs/model/CreateCapacityProviderRequest.h>
24 #include <aws/ecs/model/CreateClusterRequest.h>
25 #include <aws/ecs/model/CreateServiceRequest.h>
26 #include <aws/ecs/model/CreateTaskSetRequest.h>
27 #include <aws/ecs/model/DeleteAccountSettingRequest.h>
28 #include <aws/ecs/model/DeleteAttributesRequest.h>
29 #include <aws/ecs/model/DeleteCapacityProviderRequest.h>
30 #include <aws/ecs/model/DeleteClusterRequest.h>
31 #include <aws/ecs/model/DeleteServiceRequest.h>
32 #include <aws/ecs/model/DeleteTaskSetRequest.h>
33 #include <aws/ecs/model/DeregisterContainerInstanceRequest.h>
34 #include <aws/ecs/model/DeregisterTaskDefinitionRequest.h>
35 #include <aws/ecs/model/DescribeCapacityProvidersRequest.h>
36 #include <aws/ecs/model/DescribeClustersRequest.h>
37 #include <aws/ecs/model/DescribeContainerInstancesRequest.h>
38 #include <aws/ecs/model/DescribeServicesRequest.h>
39 #include <aws/ecs/model/DescribeTaskDefinitionRequest.h>
40 #include <aws/ecs/model/DescribeTaskSetsRequest.h>
41 #include <aws/ecs/model/DescribeTasksRequest.h>
42 #include <aws/ecs/model/DiscoverPollEndpointRequest.h>
43 #include <aws/ecs/model/ExecuteCommandRequest.h>
44 #include <aws/ecs/model/ListAccountSettingsRequest.h>
45 #include <aws/ecs/model/ListAttributesRequest.h>
46 #include <aws/ecs/model/ListClustersRequest.h>
47 #include <aws/ecs/model/ListContainerInstancesRequest.h>
48 #include <aws/ecs/model/ListServicesRequest.h>
49 #include <aws/ecs/model/ListTagsForResourceRequest.h>
50 #include <aws/ecs/model/ListTaskDefinitionFamiliesRequest.h>
51 #include <aws/ecs/model/ListTaskDefinitionsRequest.h>
52 #include <aws/ecs/model/ListTasksRequest.h>
53 #include <aws/ecs/model/PutAccountSettingRequest.h>
54 #include <aws/ecs/model/PutAccountSettingDefaultRequest.h>
55 #include <aws/ecs/model/PutAttributesRequest.h>
56 #include <aws/ecs/model/PutClusterCapacityProvidersRequest.h>
57 #include <aws/ecs/model/RegisterContainerInstanceRequest.h>
58 #include <aws/ecs/model/RegisterTaskDefinitionRequest.h>
59 #include <aws/ecs/model/RunTaskRequest.h>
60 #include <aws/ecs/model/StartTaskRequest.h>
61 #include <aws/ecs/model/StopTaskRequest.h>
62 #include <aws/ecs/model/SubmitAttachmentStateChangesRequest.h>
63 #include <aws/ecs/model/SubmitContainerStateChangeRequest.h>
64 #include <aws/ecs/model/SubmitTaskStateChangeRequest.h>
65 #include <aws/ecs/model/TagResourceRequest.h>
66 #include <aws/ecs/model/UntagResourceRequest.h>
67 #include <aws/ecs/model/UpdateCapacityProviderRequest.h>
68 #include <aws/ecs/model/UpdateClusterRequest.h>
69 #include <aws/ecs/model/UpdateClusterSettingsRequest.h>
70 #include <aws/ecs/model/UpdateContainerAgentRequest.h>
71 #include <aws/ecs/model/UpdateContainerInstancesStateRequest.h>
72 #include <aws/ecs/model/UpdateServiceRequest.h>
73 #include <aws/ecs/model/UpdateServicePrimaryTaskSetRequest.h>
74 #include <aws/ecs/model/UpdateTaskSetRequest.h>
75
76 using namespace Aws;
77 using namespace Aws::Auth;
78 using namespace Aws::Client;
79 using namespace Aws::ECS;
80 using namespace Aws::ECS::Model;
81 using namespace Aws::Http;
82 using namespace Aws::Utils::Json;
83
84 static const char* SERVICE_NAME = "ecs";
85 static const char* ALLOCATION_TAG = "ECSClient";
86
87
ECSClient(const Client::ClientConfiguration & clientConfiguration)88 ECSClient::ECSClient(const Client::ClientConfiguration& clientConfiguration) :
89 BASECLASS(clientConfiguration,
90 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
91 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
92 Aws::MakeShared<ECSErrorMarshaller>(ALLOCATION_TAG)),
93 m_executor(clientConfiguration.executor)
94 {
95 init(clientConfiguration);
96 }
97
ECSClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)98 ECSClient::ECSClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
99 BASECLASS(clientConfiguration,
100 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
101 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
102 Aws::MakeShared<ECSErrorMarshaller>(ALLOCATION_TAG)),
103 m_executor(clientConfiguration.executor)
104 {
105 init(clientConfiguration);
106 }
107
ECSClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)108 ECSClient::ECSClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
109 const Client::ClientConfiguration& clientConfiguration) :
110 BASECLASS(clientConfiguration,
111 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
112 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
113 Aws::MakeShared<ECSErrorMarshaller>(ALLOCATION_TAG)),
114 m_executor(clientConfiguration.executor)
115 {
116 init(clientConfiguration);
117 }
118
~ECSClient()119 ECSClient::~ECSClient()
120 {
121 }
122
init(const Client::ClientConfiguration & config)123 void ECSClient::init(const Client::ClientConfiguration& config)
124 {
125 SetServiceClientName("ECS");
126 m_configScheme = SchemeMapper::ToString(config.scheme);
127 if (config.endpointOverride.empty())
128 {
129 m_uri = m_configScheme + "://" + ECSEndpoint::ForRegion(config.region, config.useDualStack);
130 }
131 else
132 {
133 OverrideEndpoint(config.endpointOverride);
134 }
135 }
136
OverrideEndpoint(const Aws::String & endpoint)137 void ECSClient::OverrideEndpoint(const Aws::String& endpoint)
138 {
139 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
140 {
141 m_uri = endpoint;
142 }
143 else
144 {
145 m_uri = m_configScheme + "://" + endpoint;
146 }
147 }
148
CreateCapacityProvider(const CreateCapacityProviderRequest & request) const149 CreateCapacityProviderOutcome ECSClient::CreateCapacityProvider(const CreateCapacityProviderRequest& request) const
150 {
151 Aws::Http::URI uri = m_uri;
152 return CreateCapacityProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
153 }
154
CreateCapacityProviderCallable(const CreateCapacityProviderRequest & request) const155 CreateCapacityProviderOutcomeCallable ECSClient::CreateCapacityProviderCallable(const CreateCapacityProviderRequest& request) const
156 {
157 auto task = Aws::MakeShared< std::packaged_task< CreateCapacityProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateCapacityProvider(request); } );
158 auto packagedFunction = [task]() { (*task)(); };
159 m_executor->Submit(packagedFunction);
160 return task->get_future();
161 }
162
CreateCapacityProviderAsync(const CreateCapacityProviderRequest & request,const CreateCapacityProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const163 void ECSClient::CreateCapacityProviderAsync(const CreateCapacityProviderRequest& request, const CreateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
164 {
165 m_executor->Submit( [this, request, handler, context](){ this->CreateCapacityProviderAsyncHelper( request, handler, context ); } );
166 }
167
CreateCapacityProviderAsyncHelper(const CreateCapacityProviderRequest & request,const CreateCapacityProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const168 void ECSClient::CreateCapacityProviderAsyncHelper(const CreateCapacityProviderRequest& request, const CreateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
169 {
170 handler(this, request, CreateCapacityProvider(request), context);
171 }
172
CreateCluster(const CreateClusterRequest & request) const173 CreateClusterOutcome ECSClient::CreateCluster(const CreateClusterRequest& request) const
174 {
175 Aws::Http::URI uri = m_uri;
176 return CreateClusterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
177 }
178
CreateClusterCallable(const CreateClusterRequest & request) const179 CreateClusterOutcomeCallable ECSClient::CreateClusterCallable(const CreateClusterRequest& request) const
180 {
181 auto task = Aws::MakeShared< std::packaged_task< CreateClusterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateCluster(request); } );
182 auto packagedFunction = [task]() { (*task)(); };
183 m_executor->Submit(packagedFunction);
184 return task->get_future();
185 }
186
CreateClusterAsync(const CreateClusterRequest & request,const CreateClusterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const187 void ECSClient::CreateClusterAsync(const CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
188 {
189 m_executor->Submit( [this, request, handler, context](){ this->CreateClusterAsyncHelper( request, handler, context ); } );
190 }
191
CreateClusterAsyncHelper(const CreateClusterRequest & request,const CreateClusterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const192 void ECSClient::CreateClusterAsyncHelper(const CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
193 {
194 handler(this, request, CreateCluster(request), context);
195 }
196
CreateService(const CreateServiceRequest & request) const197 CreateServiceOutcome ECSClient::CreateService(const CreateServiceRequest& request) const
198 {
199 Aws::Http::URI uri = m_uri;
200 return CreateServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
201 }
202
CreateServiceCallable(const CreateServiceRequest & request) const203 CreateServiceOutcomeCallable ECSClient::CreateServiceCallable(const CreateServiceRequest& request) const
204 {
205 auto task = Aws::MakeShared< std::packaged_task< CreateServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateService(request); } );
206 auto packagedFunction = [task]() { (*task)(); };
207 m_executor->Submit(packagedFunction);
208 return task->get_future();
209 }
210
CreateServiceAsync(const CreateServiceRequest & request,const CreateServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const211 void ECSClient::CreateServiceAsync(const CreateServiceRequest& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
212 {
213 m_executor->Submit( [this, request, handler, context](){ this->CreateServiceAsyncHelper( request, handler, context ); } );
214 }
215
CreateServiceAsyncHelper(const CreateServiceRequest & request,const CreateServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const216 void ECSClient::CreateServiceAsyncHelper(const CreateServiceRequest& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
217 {
218 handler(this, request, CreateService(request), context);
219 }
220
CreateTaskSet(const CreateTaskSetRequest & request) const221 CreateTaskSetOutcome ECSClient::CreateTaskSet(const CreateTaskSetRequest& request) const
222 {
223 Aws::Http::URI uri = m_uri;
224 return CreateTaskSetOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
225 }
226
CreateTaskSetCallable(const CreateTaskSetRequest & request) const227 CreateTaskSetOutcomeCallable ECSClient::CreateTaskSetCallable(const CreateTaskSetRequest& request) const
228 {
229 auto task = Aws::MakeShared< std::packaged_task< CreateTaskSetOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateTaskSet(request); } );
230 auto packagedFunction = [task]() { (*task)(); };
231 m_executor->Submit(packagedFunction);
232 return task->get_future();
233 }
234
CreateTaskSetAsync(const CreateTaskSetRequest & request,const CreateTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const235 void ECSClient::CreateTaskSetAsync(const CreateTaskSetRequest& request, const CreateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
236 {
237 m_executor->Submit( [this, request, handler, context](){ this->CreateTaskSetAsyncHelper( request, handler, context ); } );
238 }
239
CreateTaskSetAsyncHelper(const CreateTaskSetRequest & request,const CreateTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const240 void ECSClient::CreateTaskSetAsyncHelper(const CreateTaskSetRequest& request, const CreateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
241 {
242 handler(this, request, CreateTaskSet(request), context);
243 }
244
DeleteAccountSetting(const DeleteAccountSettingRequest & request) const245 DeleteAccountSettingOutcome ECSClient::DeleteAccountSetting(const DeleteAccountSettingRequest& request) const
246 {
247 Aws::Http::URI uri = m_uri;
248 return DeleteAccountSettingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
249 }
250
DeleteAccountSettingCallable(const DeleteAccountSettingRequest & request) const251 DeleteAccountSettingOutcomeCallable ECSClient::DeleteAccountSettingCallable(const DeleteAccountSettingRequest& request) const
252 {
253 auto task = Aws::MakeShared< std::packaged_task< DeleteAccountSettingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAccountSetting(request); } );
254 auto packagedFunction = [task]() { (*task)(); };
255 m_executor->Submit(packagedFunction);
256 return task->get_future();
257 }
258
DeleteAccountSettingAsync(const DeleteAccountSettingRequest & request,const DeleteAccountSettingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const259 void ECSClient::DeleteAccountSettingAsync(const DeleteAccountSettingRequest& request, const DeleteAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
260 {
261 m_executor->Submit( [this, request, handler, context](){ this->DeleteAccountSettingAsyncHelper( request, handler, context ); } );
262 }
263
DeleteAccountSettingAsyncHelper(const DeleteAccountSettingRequest & request,const DeleteAccountSettingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const264 void ECSClient::DeleteAccountSettingAsyncHelper(const DeleteAccountSettingRequest& request, const DeleteAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
265 {
266 handler(this, request, DeleteAccountSetting(request), context);
267 }
268
DeleteAttributes(const DeleteAttributesRequest & request) const269 DeleteAttributesOutcome ECSClient::DeleteAttributes(const DeleteAttributesRequest& request) const
270 {
271 Aws::Http::URI uri = m_uri;
272 return DeleteAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
273 }
274
DeleteAttributesCallable(const DeleteAttributesRequest & request) const275 DeleteAttributesOutcomeCallable ECSClient::DeleteAttributesCallable(const DeleteAttributesRequest& request) const
276 {
277 auto task = Aws::MakeShared< std::packaged_task< DeleteAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAttributes(request); } );
278 auto packagedFunction = [task]() { (*task)(); };
279 m_executor->Submit(packagedFunction);
280 return task->get_future();
281 }
282
DeleteAttributesAsync(const DeleteAttributesRequest & request,const DeleteAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const283 void ECSClient::DeleteAttributesAsync(const DeleteAttributesRequest& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
284 {
285 m_executor->Submit( [this, request, handler, context](){ this->DeleteAttributesAsyncHelper( request, handler, context ); } );
286 }
287
DeleteAttributesAsyncHelper(const DeleteAttributesRequest & request,const DeleteAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const288 void ECSClient::DeleteAttributesAsyncHelper(const DeleteAttributesRequest& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
289 {
290 handler(this, request, DeleteAttributes(request), context);
291 }
292
DeleteCapacityProvider(const DeleteCapacityProviderRequest & request) const293 DeleteCapacityProviderOutcome ECSClient::DeleteCapacityProvider(const DeleteCapacityProviderRequest& request) const
294 {
295 Aws::Http::URI uri = m_uri;
296 return DeleteCapacityProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
297 }
298
DeleteCapacityProviderCallable(const DeleteCapacityProviderRequest & request) const299 DeleteCapacityProviderOutcomeCallable ECSClient::DeleteCapacityProviderCallable(const DeleteCapacityProviderRequest& request) const
300 {
301 auto task = Aws::MakeShared< std::packaged_task< DeleteCapacityProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteCapacityProvider(request); } );
302 auto packagedFunction = [task]() { (*task)(); };
303 m_executor->Submit(packagedFunction);
304 return task->get_future();
305 }
306
DeleteCapacityProviderAsync(const DeleteCapacityProviderRequest & request,const DeleteCapacityProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const307 void ECSClient::DeleteCapacityProviderAsync(const DeleteCapacityProviderRequest& request, const DeleteCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
308 {
309 m_executor->Submit( [this, request, handler, context](){ this->DeleteCapacityProviderAsyncHelper( request, handler, context ); } );
310 }
311
DeleteCapacityProviderAsyncHelper(const DeleteCapacityProviderRequest & request,const DeleteCapacityProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const312 void ECSClient::DeleteCapacityProviderAsyncHelper(const DeleteCapacityProviderRequest& request, const DeleteCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
313 {
314 handler(this, request, DeleteCapacityProvider(request), context);
315 }
316
DeleteCluster(const DeleteClusterRequest & request) const317 DeleteClusterOutcome ECSClient::DeleteCluster(const DeleteClusterRequest& request) const
318 {
319 Aws::Http::URI uri = m_uri;
320 return DeleteClusterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
321 }
322
DeleteClusterCallable(const DeleteClusterRequest & request) const323 DeleteClusterOutcomeCallable ECSClient::DeleteClusterCallable(const DeleteClusterRequest& request) const
324 {
325 auto task = Aws::MakeShared< std::packaged_task< DeleteClusterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteCluster(request); } );
326 auto packagedFunction = [task]() { (*task)(); };
327 m_executor->Submit(packagedFunction);
328 return task->get_future();
329 }
330
DeleteClusterAsync(const DeleteClusterRequest & request,const DeleteClusterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const331 void ECSClient::DeleteClusterAsync(const DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
332 {
333 m_executor->Submit( [this, request, handler, context](){ this->DeleteClusterAsyncHelper( request, handler, context ); } );
334 }
335
DeleteClusterAsyncHelper(const DeleteClusterRequest & request,const DeleteClusterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const336 void ECSClient::DeleteClusterAsyncHelper(const DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
337 {
338 handler(this, request, DeleteCluster(request), context);
339 }
340
DeleteService(const DeleteServiceRequest & request) const341 DeleteServiceOutcome ECSClient::DeleteService(const DeleteServiceRequest& request) const
342 {
343 Aws::Http::URI uri = m_uri;
344 return DeleteServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
345 }
346
DeleteServiceCallable(const DeleteServiceRequest & request) const347 DeleteServiceOutcomeCallable ECSClient::DeleteServiceCallable(const DeleteServiceRequest& request) const
348 {
349 auto task = Aws::MakeShared< std::packaged_task< DeleteServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteService(request); } );
350 auto packagedFunction = [task]() { (*task)(); };
351 m_executor->Submit(packagedFunction);
352 return task->get_future();
353 }
354
DeleteServiceAsync(const DeleteServiceRequest & request,const DeleteServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const355 void ECSClient::DeleteServiceAsync(const DeleteServiceRequest& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
356 {
357 m_executor->Submit( [this, request, handler, context](){ this->DeleteServiceAsyncHelper( request, handler, context ); } );
358 }
359
DeleteServiceAsyncHelper(const DeleteServiceRequest & request,const DeleteServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const360 void ECSClient::DeleteServiceAsyncHelper(const DeleteServiceRequest& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
361 {
362 handler(this, request, DeleteService(request), context);
363 }
364
DeleteTaskSet(const DeleteTaskSetRequest & request) const365 DeleteTaskSetOutcome ECSClient::DeleteTaskSet(const DeleteTaskSetRequest& request) const
366 {
367 Aws::Http::URI uri = m_uri;
368 return DeleteTaskSetOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
369 }
370
DeleteTaskSetCallable(const DeleteTaskSetRequest & request) const371 DeleteTaskSetOutcomeCallable ECSClient::DeleteTaskSetCallable(const DeleteTaskSetRequest& request) const
372 {
373 auto task = Aws::MakeShared< std::packaged_task< DeleteTaskSetOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteTaskSet(request); } );
374 auto packagedFunction = [task]() { (*task)(); };
375 m_executor->Submit(packagedFunction);
376 return task->get_future();
377 }
378
DeleteTaskSetAsync(const DeleteTaskSetRequest & request,const DeleteTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const379 void ECSClient::DeleteTaskSetAsync(const DeleteTaskSetRequest& request, const DeleteTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
380 {
381 m_executor->Submit( [this, request, handler, context](){ this->DeleteTaskSetAsyncHelper( request, handler, context ); } );
382 }
383
DeleteTaskSetAsyncHelper(const DeleteTaskSetRequest & request,const DeleteTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const384 void ECSClient::DeleteTaskSetAsyncHelper(const DeleteTaskSetRequest& request, const DeleteTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
385 {
386 handler(this, request, DeleteTaskSet(request), context);
387 }
388
DeregisterContainerInstance(const DeregisterContainerInstanceRequest & request) const389 DeregisterContainerInstanceOutcome ECSClient::DeregisterContainerInstance(const DeregisterContainerInstanceRequest& request) const
390 {
391 Aws::Http::URI uri = m_uri;
392 return DeregisterContainerInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
393 }
394
DeregisterContainerInstanceCallable(const DeregisterContainerInstanceRequest & request) const395 DeregisterContainerInstanceOutcomeCallable ECSClient::DeregisterContainerInstanceCallable(const DeregisterContainerInstanceRequest& request) const
396 {
397 auto task = Aws::MakeShared< std::packaged_task< DeregisterContainerInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeregisterContainerInstance(request); } );
398 auto packagedFunction = [task]() { (*task)(); };
399 m_executor->Submit(packagedFunction);
400 return task->get_future();
401 }
402
DeregisterContainerInstanceAsync(const DeregisterContainerInstanceRequest & request,const DeregisterContainerInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const403 void ECSClient::DeregisterContainerInstanceAsync(const DeregisterContainerInstanceRequest& request, const DeregisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
404 {
405 m_executor->Submit( [this, request, handler, context](){ this->DeregisterContainerInstanceAsyncHelper( request, handler, context ); } );
406 }
407
DeregisterContainerInstanceAsyncHelper(const DeregisterContainerInstanceRequest & request,const DeregisterContainerInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const408 void ECSClient::DeregisterContainerInstanceAsyncHelper(const DeregisterContainerInstanceRequest& request, const DeregisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
409 {
410 handler(this, request, DeregisterContainerInstance(request), context);
411 }
412
DeregisterTaskDefinition(const DeregisterTaskDefinitionRequest & request) const413 DeregisterTaskDefinitionOutcome ECSClient::DeregisterTaskDefinition(const DeregisterTaskDefinitionRequest& request) const
414 {
415 Aws::Http::URI uri = m_uri;
416 return DeregisterTaskDefinitionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
417 }
418
DeregisterTaskDefinitionCallable(const DeregisterTaskDefinitionRequest & request) const419 DeregisterTaskDefinitionOutcomeCallable ECSClient::DeregisterTaskDefinitionCallable(const DeregisterTaskDefinitionRequest& request) const
420 {
421 auto task = Aws::MakeShared< std::packaged_task< DeregisterTaskDefinitionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeregisterTaskDefinition(request); } );
422 auto packagedFunction = [task]() { (*task)(); };
423 m_executor->Submit(packagedFunction);
424 return task->get_future();
425 }
426
DeregisterTaskDefinitionAsync(const DeregisterTaskDefinitionRequest & request,const DeregisterTaskDefinitionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const427 void ECSClient::DeregisterTaskDefinitionAsync(const DeregisterTaskDefinitionRequest& request, const DeregisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
428 {
429 m_executor->Submit( [this, request, handler, context](){ this->DeregisterTaskDefinitionAsyncHelper( request, handler, context ); } );
430 }
431
DeregisterTaskDefinitionAsyncHelper(const DeregisterTaskDefinitionRequest & request,const DeregisterTaskDefinitionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const432 void ECSClient::DeregisterTaskDefinitionAsyncHelper(const DeregisterTaskDefinitionRequest& request, const DeregisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
433 {
434 handler(this, request, DeregisterTaskDefinition(request), context);
435 }
436
DescribeCapacityProviders(const DescribeCapacityProvidersRequest & request) const437 DescribeCapacityProvidersOutcome ECSClient::DescribeCapacityProviders(const DescribeCapacityProvidersRequest& request) const
438 {
439 Aws::Http::URI uri = m_uri;
440 return DescribeCapacityProvidersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
441 }
442
DescribeCapacityProvidersCallable(const DescribeCapacityProvidersRequest & request) const443 DescribeCapacityProvidersOutcomeCallable ECSClient::DescribeCapacityProvidersCallable(const DescribeCapacityProvidersRequest& request) const
444 {
445 auto task = Aws::MakeShared< std::packaged_task< DescribeCapacityProvidersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeCapacityProviders(request); } );
446 auto packagedFunction = [task]() { (*task)(); };
447 m_executor->Submit(packagedFunction);
448 return task->get_future();
449 }
450
DescribeCapacityProvidersAsync(const DescribeCapacityProvidersRequest & request,const DescribeCapacityProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const451 void ECSClient::DescribeCapacityProvidersAsync(const DescribeCapacityProvidersRequest& request, const DescribeCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
452 {
453 m_executor->Submit( [this, request, handler, context](){ this->DescribeCapacityProvidersAsyncHelper( request, handler, context ); } );
454 }
455
DescribeCapacityProvidersAsyncHelper(const DescribeCapacityProvidersRequest & request,const DescribeCapacityProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const456 void ECSClient::DescribeCapacityProvidersAsyncHelper(const DescribeCapacityProvidersRequest& request, const DescribeCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
457 {
458 handler(this, request, DescribeCapacityProviders(request), context);
459 }
460
DescribeClusters(const DescribeClustersRequest & request) const461 DescribeClustersOutcome ECSClient::DescribeClusters(const DescribeClustersRequest& request) const
462 {
463 Aws::Http::URI uri = m_uri;
464 return DescribeClustersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
465 }
466
DescribeClustersCallable(const DescribeClustersRequest & request) const467 DescribeClustersOutcomeCallable ECSClient::DescribeClustersCallable(const DescribeClustersRequest& request) const
468 {
469 auto task = Aws::MakeShared< std::packaged_task< DescribeClustersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeClusters(request); } );
470 auto packagedFunction = [task]() { (*task)(); };
471 m_executor->Submit(packagedFunction);
472 return task->get_future();
473 }
474
DescribeClustersAsync(const DescribeClustersRequest & request,const DescribeClustersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const475 void ECSClient::DescribeClustersAsync(const DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
476 {
477 m_executor->Submit( [this, request, handler, context](){ this->DescribeClustersAsyncHelper( request, handler, context ); } );
478 }
479
DescribeClustersAsyncHelper(const DescribeClustersRequest & request,const DescribeClustersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const480 void ECSClient::DescribeClustersAsyncHelper(const DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
481 {
482 handler(this, request, DescribeClusters(request), context);
483 }
484
DescribeContainerInstances(const DescribeContainerInstancesRequest & request) const485 DescribeContainerInstancesOutcome ECSClient::DescribeContainerInstances(const DescribeContainerInstancesRequest& request) const
486 {
487 Aws::Http::URI uri = m_uri;
488 return DescribeContainerInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
489 }
490
DescribeContainerInstancesCallable(const DescribeContainerInstancesRequest & request) const491 DescribeContainerInstancesOutcomeCallable ECSClient::DescribeContainerInstancesCallable(const DescribeContainerInstancesRequest& request) const
492 {
493 auto task = Aws::MakeShared< std::packaged_task< DescribeContainerInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeContainerInstances(request); } );
494 auto packagedFunction = [task]() { (*task)(); };
495 m_executor->Submit(packagedFunction);
496 return task->get_future();
497 }
498
DescribeContainerInstancesAsync(const DescribeContainerInstancesRequest & request,const DescribeContainerInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const499 void ECSClient::DescribeContainerInstancesAsync(const DescribeContainerInstancesRequest& request, const DescribeContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
500 {
501 m_executor->Submit( [this, request, handler, context](){ this->DescribeContainerInstancesAsyncHelper( request, handler, context ); } );
502 }
503
DescribeContainerInstancesAsyncHelper(const DescribeContainerInstancesRequest & request,const DescribeContainerInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const504 void ECSClient::DescribeContainerInstancesAsyncHelper(const DescribeContainerInstancesRequest& request, const DescribeContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
505 {
506 handler(this, request, DescribeContainerInstances(request), context);
507 }
508
DescribeServices(const DescribeServicesRequest & request) const509 DescribeServicesOutcome ECSClient::DescribeServices(const DescribeServicesRequest& request) const
510 {
511 Aws::Http::URI uri = m_uri;
512 return DescribeServicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
513 }
514
DescribeServicesCallable(const DescribeServicesRequest & request) const515 DescribeServicesOutcomeCallable ECSClient::DescribeServicesCallable(const DescribeServicesRequest& request) const
516 {
517 auto task = Aws::MakeShared< std::packaged_task< DescribeServicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeServices(request); } );
518 auto packagedFunction = [task]() { (*task)(); };
519 m_executor->Submit(packagedFunction);
520 return task->get_future();
521 }
522
DescribeServicesAsync(const DescribeServicesRequest & request,const DescribeServicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const523 void ECSClient::DescribeServicesAsync(const DescribeServicesRequest& request, const DescribeServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
524 {
525 m_executor->Submit( [this, request, handler, context](){ this->DescribeServicesAsyncHelper( request, handler, context ); } );
526 }
527
DescribeServicesAsyncHelper(const DescribeServicesRequest & request,const DescribeServicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const528 void ECSClient::DescribeServicesAsyncHelper(const DescribeServicesRequest& request, const DescribeServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
529 {
530 handler(this, request, DescribeServices(request), context);
531 }
532
DescribeTaskDefinition(const DescribeTaskDefinitionRequest & request) const533 DescribeTaskDefinitionOutcome ECSClient::DescribeTaskDefinition(const DescribeTaskDefinitionRequest& request) const
534 {
535 Aws::Http::URI uri = m_uri;
536 return DescribeTaskDefinitionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
537 }
538
DescribeTaskDefinitionCallable(const DescribeTaskDefinitionRequest & request) const539 DescribeTaskDefinitionOutcomeCallable ECSClient::DescribeTaskDefinitionCallable(const DescribeTaskDefinitionRequest& request) const
540 {
541 auto task = Aws::MakeShared< std::packaged_task< DescribeTaskDefinitionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTaskDefinition(request); } );
542 auto packagedFunction = [task]() { (*task)(); };
543 m_executor->Submit(packagedFunction);
544 return task->get_future();
545 }
546
DescribeTaskDefinitionAsync(const DescribeTaskDefinitionRequest & request,const DescribeTaskDefinitionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const547 void ECSClient::DescribeTaskDefinitionAsync(const DescribeTaskDefinitionRequest& request, const DescribeTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
548 {
549 m_executor->Submit( [this, request, handler, context](){ this->DescribeTaskDefinitionAsyncHelper( request, handler, context ); } );
550 }
551
DescribeTaskDefinitionAsyncHelper(const DescribeTaskDefinitionRequest & request,const DescribeTaskDefinitionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const552 void ECSClient::DescribeTaskDefinitionAsyncHelper(const DescribeTaskDefinitionRequest& request, const DescribeTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
553 {
554 handler(this, request, DescribeTaskDefinition(request), context);
555 }
556
DescribeTaskSets(const DescribeTaskSetsRequest & request) const557 DescribeTaskSetsOutcome ECSClient::DescribeTaskSets(const DescribeTaskSetsRequest& request) const
558 {
559 Aws::Http::URI uri = m_uri;
560 return DescribeTaskSetsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
561 }
562
DescribeTaskSetsCallable(const DescribeTaskSetsRequest & request) const563 DescribeTaskSetsOutcomeCallable ECSClient::DescribeTaskSetsCallable(const DescribeTaskSetsRequest& request) const
564 {
565 auto task = Aws::MakeShared< std::packaged_task< DescribeTaskSetsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTaskSets(request); } );
566 auto packagedFunction = [task]() { (*task)(); };
567 m_executor->Submit(packagedFunction);
568 return task->get_future();
569 }
570
DescribeTaskSetsAsync(const DescribeTaskSetsRequest & request,const DescribeTaskSetsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const571 void ECSClient::DescribeTaskSetsAsync(const DescribeTaskSetsRequest& request, const DescribeTaskSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
572 {
573 m_executor->Submit( [this, request, handler, context](){ this->DescribeTaskSetsAsyncHelper( request, handler, context ); } );
574 }
575
DescribeTaskSetsAsyncHelper(const DescribeTaskSetsRequest & request,const DescribeTaskSetsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const576 void ECSClient::DescribeTaskSetsAsyncHelper(const DescribeTaskSetsRequest& request, const DescribeTaskSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
577 {
578 handler(this, request, DescribeTaskSets(request), context);
579 }
580
DescribeTasks(const DescribeTasksRequest & request) const581 DescribeTasksOutcome ECSClient::DescribeTasks(const DescribeTasksRequest& request) const
582 {
583 Aws::Http::URI uri = m_uri;
584 return DescribeTasksOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
585 }
586
DescribeTasksCallable(const DescribeTasksRequest & request) const587 DescribeTasksOutcomeCallable ECSClient::DescribeTasksCallable(const DescribeTasksRequest& request) const
588 {
589 auto task = Aws::MakeShared< std::packaged_task< DescribeTasksOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTasks(request); } );
590 auto packagedFunction = [task]() { (*task)(); };
591 m_executor->Submit(packagedFunction);
592 return task->get_future();
593 }
594
DescribeTasksAsync(const DescribeTasksRequest & request,const DescribeTasksResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const595 void ECSClient::DescribeTasksAsync(const DescribeTasksRequest& request, const DescribeTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
596 {
597 m_executor->Submit( [this, request, handler, context](){ this->DescribeTasksAsyncHelper( request, handler, context ); } );
598 }
599
DescribeTasksAsyncHelper(const DescribeTasksRequest & request,const DescribeTasksResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const600 void ECSClient::DescribeTasksAsyncHelper(const DescribeTasksRequest& request, const DescribeTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
601 {
602 handler(this, request, DescribeTasks(request), context);
603 }
604
DiscoverPollEndpoint(const DiscoverPollEndpointRequest & request) const605 DiscoverPollEndpointOutcome ECSClient::DiscoverPollEndpoint(const DiscoverPollEndpointRequest& request) const
606 {
607 Aws::Http::URI uri = m_uri;
608 return DiscoverPollEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
609 }
610
DiscoverPollEndpointCallable(const DiscoverPollEndpointRequest & request) const611 DiscoverPollEndpointOutcomeCallable ECSClient::DiscoverPollEndpointCallable(const DiscoverPollEndpointRequest& request) const
612 {
613 auto task = Aws::MakeShared< std::packaged_task< DiscoverPollEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DiscoverPollEndpoint(request); } );
614 auto packagedFunction = [task]() { (*task)(); };
615 m_executor->Submit(packagedFunction);
616 return task->get_future();
617 }
618
DiscoverPollEndpointAsync(const DiscoverPollEndpointRequest & request,const DiscoverPollEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const619 void ECSClient::DiscoverPollEndpointAsync(const DiscoverPollEndpointRequest& request, const DiscoverPollEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
620 {
621 m_executor->Submit( [this, request, handler, context](){ this->DiscoverPollEndpointAsyncHelper( request, handler, context ); } );
622 }
623
DiscoverPollEndpointAsyncHelper(const DiscoverPollEndpointRequest & request,const DiscoverPollEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const624 void ECSClient::DiscoverPollEndpointAsyncHelper(const DiscoverPollEndpointRequest& request, const DiscoverPollEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
625 {
626 handler(this, request, DiscoverPollEndpoint(request), context);
627 }
628
ExecuteCommand(const ExecuteCommandRequest & request) const629 ExecuteCommandOutcome ECSClient::ExecuteCommand(const ExecuteCommandRequest& request) const
630 {
631 Aws::Http::URI uri = m_uri;
632 return ExecuteCommandOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
633 }
634
ExecuteCommandCallable(const ExecuteCommandRequest & request) const635 ExecuteCommandOutcomeCallable ECSClient::ExecuteCommandCallable(const ExecuteCommandRequest& request) const
636 {
637 auto task = Aws::MakeShared< std::packaged_task< ExecuteCommandOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ExecuteCommand(request); } );
638 auto packagedFunction = [task]() { (*task)(); };
639 m_executor->Submit(packagedFunction);
640 return task->get_future();
641 }
642
ExecuteCommandAsync(const ExecuteCommandRequest & request,const ExecuteCommandResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const643 void ECSClient::ExecuteCommandAsync(const ExecuteCommandRequest& request, const ExecuteCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
644 {
645 m_executor->Submit( [this, request, handler, context](){ this->ExecuteCommandAsyncHelper( request, handler, context ); } );
646 }
647
ExecuteCommandAsyncHelper(const ExecuteCommandRequest & request,const ExecuteCommandResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const648 void ECSClient::ExecuteCommandAsyncHelper(const ExecuteCommandRequest& request, const ExecuteCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
649 {
650 handler(this, request, ExecuteCommand(request), context);
651 }
652
ListAccountSettings(const ListAccountSettingsRequest & request) const653 ListAccountSettingsOutcome ECSClient::ListAccountSettings(const ListAccountSettingsRequest& request) const
654 {
655 Aws::Http::URI uri = m_uri;
656 return ListAccountSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
657 }
658
ListAccountSettingsCallable(const ListAccountSettingsRequest & request) const659 ListAccountSettingsOutcomeCallable ECSClient::ListAccountSettingsCallable(const ListAccountSettingsRequest& request) const
660 {
661 auto task = Aws::MakeShared< std::packaged_task< ListAccountSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAccountSettings(request); } );
662 auto packagedFunction = [task]() { (*task)(); };
663 m_executor->Submit(packagedFunction);
664 return task->get_future();
665 }
666
ListAccountSettingsAsync(const ListAccountSettingsRequest & request,const ListAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const667 void ECSClient::ListAccountSettingsAsync(const ListAccountSettingsRequest& request, const ListAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
668 {
669 m_executor->Submit( [this, request, handler, context](){ this->ListAccountSettingsAsyncHelper( request, handler, context ); } );
670 }
671
ListAccountSettingsAsyncHelper(const ListAccountSettingsRequest & request,const ListAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const672 void ECSClient::ListAccountSettingsAsyncHelper(const ListAccountSettingsRequest& request, const ListAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
673 {
674 handler(this, request, ListAccountSettings(request), context);
675 }
676
ListAttributes(const ListAttributesRequest & request) const677 ListAttributesOutcome ECSClient::ListAttributes(const ListAttributesRequest& request) const
678 {
679 Aws::Http::URI uri = m_uri;
680 return ListAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
681 }
682
ListAttributesCallable(const ListAttributesRequest & request) const683 ListAttributesOutcomeCallable ECSClient::ListAttributesCallable(const ListAttributesRequest& request) const
684 {
685 auto task = Aws::MakeShared< std::packaged_task< ListAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAttributes(request); } );
686 auto packagedFunction = [task]() { (*task)(); };
687 m_executor->Submit(packagedFunction);
688 return task->get_future();
689 }
690
ListAttributesAsync(const ListAttributesRequest & request,const ListAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const691 void ECSClient::ListAttributesAsync(const ListAttributesRequest& request, const ListAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
692 {
693 m_executor->Submit( [this, request, handler, context](){ this->ListAttributesAsyncHelper( request, handler, context ); } );
694 }
695
ListAttributesAsyncHelper(const ListAttributesRequest & request,const ListAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const696 void ECSClient::ListAttributesAsyncHelper(const ListAttributesRequest& request, const ListAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
697 {
698 handler(this, request, ListAttributes(request), context);
699 }
700
ListClusters(const ListClustersRequest & request) const701 ListClustersOutcome ECSClient::ListClusters(const ListClustersRequest& request) const
702 {
703 Aws::Http::URI uri = m_uri;
704 return ListClustersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
705 }
706
ListClustersCallable(const ListClustersRequest & request) const707 ListClustersOutcomeCallable ECSClient::ListClustersCallable(const ListClustersRequest& request) const
708 {
709 auto task = Aws::MakeShared< std::packaged_task< ListClustersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListClusters(request); } );
710 auto packagedFunction = [task]() { (*task)(); };
711 m_executor->Submit(packagedFunction);
712 return task->get_future();
713 }
714
ListClustersAsync(const ListClustersRequest & request,const ListClustersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const715 void ECSClient::ListClustersAsync(const ListClustersRequest& request, const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
716 {
717 m_executor->Submit( [this, request, handler, context](){ this->ListClustersAsyncHelper( request, handler, context ); } );
718 }
719
ListClustersAsyncHelper(const ListClustersRequest & request,const ListClustersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const720 void ECSClient::ListClustersAsyncHelper(const ListClustersRequest& request, const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
721 {
722 handler(this, request, ListClusters(request), context);
723 }
724
ListContainerInstances(const ListContainerInstancesRequest & request) const725 ListContainerInstancesOutcome ECSClient::ListContainerInstances(const ListContainerInstancesRequest& request) const
726 {
727 Aws::Http::URI uri = m_uri;
728 return ListContainerInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
729 }
730
ListContainerInstancesCallable(const ListContainerInstancesRequest & request) const731 ListContainerInstancesOutcomeCallable ECSClient::ListContainerInstancesCallable(const ListContainerInstancesRequest& request) const
732 {
733 auto task = Aws::MakeShared< std::packaged_task< ListContainerInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListContainerInstances(request); } );
734 auto packagedFunction = [task]() { (*task)(); };
735 m_executor->Submit(packagedFunction);
736 return task->get_future();
737 }
738
ListContainerInstancesAsync(const ListContainerInstancesRequest & request,const ListContainerInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const739 void ECSClient::ListContainerInstancesAsync(const ListContainerInstancesRequest& request, const ListContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
740 {
741 m_executor->Submit( [this, request, handler, context](){ this->ListContainerInstancesAsyncHelper( request, handler, context ); } );
742 }
743
ListContainerInstancesAsyncHelper(const ListContainerInstancesRequest & request,const ListContainerInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const744 void ECSClient::ListContainerInstancesAsyncHelper(const ListContainerInstancesRequest& request, const ListContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
745 {
746 handler(this, request, ListContainerInstances(request), context);
747 }
748
ListServices(const ListServicesRequest & request) const749 ListServicesOutcome ECSClient::ListServices(const ListServicesRequest& request) const
750 {
751 Aws::Http::URI uri = m_uri;
752 return ListServicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
753 }
754
ListServicesCallable(const ListServicesRequest & request) const755 ListServicesOutcomeCallable ECSClient::ListServicesCallable(const ListServicesRequest& request) const
756 {
757 auto task = Aws::MakeShared< std::packaged_task< ListServicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListServices(request); } );
758 auto packagedFunction = [task]() { (*task)(); };
759 m_executor->Submit(packagedFunction);
760 return task->get_future();
761 }
762
ListServicesAsync(const ListServicesRequest & request,const ListServicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const763 void ECSClient::ListServicesAsync(const ListServicesRequest& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
764 {
765 m_executor->Submit( [this, request, handler, context](){ this->ListServicesAsyncHelper( request, handler, context ); } );
766 }
767
ListServicesAsyncHelper(const ListServicesRequest & request,const ListServicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const768 void ECSClient::ListServicesAsyncHelper(const ListServicesRequest& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
769 {
770 handler(this, request, ListServices(request), context);
771 }
772
ListTagsForResource(const ListTagsForResourceRequest & request) const773 ListTagsForResourceOutcome ECSClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
774 {
775 Aws::Http::URI uri = m_uri;
776 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
777 }
778
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const779 ListTagsForResourceOutcomeCallable ECSClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
780 {
781 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
782 auto packagedFunction = [task]() { (*task)(); };
783 m_executor->Submit(packagedFunction);
784 return task->get_future();
785 }
786
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const787 void ECSClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
788 {
789 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
790 }
791
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const792 void ECSClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
793 {
794 handler(this, request, ListTagsForResource(request), context);
795 }
796
ListTaskDefinitionFamilies(const ListTaskDefinitionFamiliesRequest & request) const797 ListTaskDefinitionFamiliesOutcome ECSClient::ListTaskDefinitionFamilies(const ListTaskDefinitionFamiliesRequest& request) const
798 {
799 Aws::Http::URI uri = m_uri;
800 return ListTaskDefinitionFamiliesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
801 }
802
ListTaskDefinitionFamiliesCallable(const ListTaskDefinitionFamiliesRequest & request) const803 ListTaskDefinitionFamiliesOutcomeCallable ECSClient::ListTaskDefinitionFamiliesCallable(const ListTaskDefinitionFamiliesRequest& request) const
804 {
805 auto task = Aws::MakeShared< std::packaged_task< ListTaskDefinitionFamiliesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTaskDefinitionFamilies(request); } );
806 auto packagedFunction = [task]() { (*task)(); };
807 m_executor->Submit(packagedFunction);
808 return task->get_future();
809 }
810
ListTaskDefinitionFamiliesAsync(const ListTaskDefinitionFamiliesRequest & request,const ListTaskDefinitionFamiliesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const811 void ECSClient::ListTaskDefinitionFamiliesAsync(const ListTaskDefinitionFamiliesRequest& request, const ListTaskDefinitionFamiliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
812 {
813 m_executor->Submit( [this, request, handler, context](){ this->ListTaskDefinitionFamiliesAsyncHelper( request, handler, context ); } );
814 }
815
ListTaskDefinitionFamiliesAsyncHelper(const ListTaskDefinitionFamiliesRequest & request,const ListTaskDefinitionFamiliesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const816 void ECSClient::ListTaskDefinitionFamiliesAsyncHelper(const ListTaskDefinitionFamiliesRequest& request, const ListTaskDefinitionFamiliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
817 {
818 handler(this, request, ListTaskDefinitionFamilies(request), context);
819 }
820
ListTaskDefinitions(const ListTaskDefinitionsRequest & request) const821 ListTaskDefinitionsOutcome ECSClient::ListTaskDefinitions(const ListTaskDefinitionsRequest& request) const
822 {
823 Aws::Http::URI uri = m_uri;
824 return ListTaskDefinitionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
825 }
826
ListTaskDefinitionsCallable(const ListTaskDefinitionsRequest & request) const827 ListTaskDefinitionsOutcomeCallable ECSClient::ListTaskDefinitionsCallable(const ListTaskDefinitionsRequest& request) const
828 {
829 auto task = Aws::MakeShared< std::packaged_task< ListTaskDefinitionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTaskDefinitions(request); } );
830 auto packagedFunction = [task]() { (*task)(); };
831 m_executor->Submit(packagedFunction);
832 return task->get_future();
833 }
834
ListTaskDefinitionsAsync(const ListTaskDefinitionsRequest & request,const ListTaskDefinitionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const835 void ECSClient::ListTaskDefinitionsAsync(const ListTaskDefinitionsRequest& request, const ListTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
836 {
837 m_executor->Submit( [this, request, handler, context](){ this->ListTaskDefinitionsAsyncHelper( request, handler, context ); } );
838 }
839
ListTaskDefinitionsAsyncHelper(const ListTaskDefinitionsRequest & request,const ListTaskDefinitionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const840 void ECSClient::ListTaskDefinitionsAsyncHelper(const ListTaskDefinitionsRequest& request, const ListTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
841 {
842 handler(this, request, ListTaskDefinitions(request), context);
843 }
844
ListTasks(const ListTasksRequest & request) const845 ListTasksOutcome ECSClient::ListTasks(const ListTasksRequest& request) const
846 {
847 Aws::Http::URI uri = m_uri;
848 return ListTasksOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
849 }
850
ListTasksCallable(const ListTasksRequest & request) const851 ListTasksOutcomeCallable ECSClient::ListTasksCallable(const ListTasksRequest& request) const
852 {
853 auto task = Aws::MakeShared< std::packaged_task< ListTasksOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTasks(request); } );
854 auto packagedFunction = [task]() { (*task)(); };
855 m_executor->Submit(packagedFunction);
856 return task->get_future();
857 }
858
ListTasksAsync(const ListTasksRequest & request,const ListTasksResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const859 void ECSClient::ListTasksAsync(const ListTasksRequest& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
860 {
861 m_executor->Submit( [this, request, handler, context](){ this->ListTasksAsyncHelper( request, handler, context ); } );
862 }
863
ListTasksAsyncHelper(const ListTasksRequest & request,const ListTasksResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const864 void ECSClient::ListTasksAsyncHelper(const ListTasksRequest& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
865 {
866 handler(this, request, ListTasks(request), context);
867 }
868
PutAccountSetting(const PutAccountSettingRequest & request) const869 PutAccountSettingOutcome ECSClient::PutAccountSetting(const PutAccountSettingRequest& request) const
870 {
871 Aws::Http::URI uri = m_uri;
872 return PutAccountSettingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
873 }
874
PutAccountSettingCallable(const PutAccountSettingRequest & request) const875 PutAccountSettingOutcomeCallable ECSClient::PutAccountSettingCallable(const PutAccountSettingRequest& request) const
876 {
877 auto task = Aws::MakeShared< std::packaged_task< PutAccountSettingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutAccountSetting(request); } );
878 auto packagedFunction = [task]() { (*task)(); };
879 m_executor->Submit(packagedFunction);
880 return task->get_future();
881 }
882
PutAccountSettingAsync(const PutAccountSettingRequest & request,const PutAccountSettingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const883 void ECSClient::PutAccountSettingAsync(const PutAccountSettingRequest& request, const PutAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
884 {
885 m_executor->Submit( [this, request, handler, context](){ this->PutAccountSettingAsyncHelper( request, handler, context ); } );
886 }
887
PutAccountSettingAsyncHelper(const PutAccountSettingRequest & request,const PutAccountSettingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const888 void ECSClient::PutAccountSettingAsyncHelper(const PutAccountSettingRequest& request, const PutAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
889 {
890 handler(this, request, PutAccountSetting(request), context);
891 }
892
PutAccountSettingDefault(const PutAccountSettingDefaultRequest & request) const893 PutAccountSettingDefaultOutcome ECSClient::PutAccountSettingDefault(const PutAccountSettingDefaultRequest& request) const
894 {
895 Aws::Http::URI uri = m_uri;
896 return PutAccountSettingDefaultOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
897 }
898
PutAccountSettingDefaultCallable(const PutAccountSettingDefaultRequest & request) const899 PutAccountSettingDefaultOutcomeCallable ECSClient::PutAccountSettingDefaultCallable(const PutAccountSettingDefaultRequest& request) const
900 {
901 auto task = Aws::MakeShared< std::packaged_task< PutAccountSettingDefaultOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutAccountSettingDefault(request); } );
902 auto packagedFunction = [task]() { (*task)(); };
903 m_executor->Submit(packagedFunction);
904 return task->get_future();
905 }
906
PutAccountSettingDefaultAsync(const PutAccountSettingDefaultRequest & request,const PutAccountSettingDefaultResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const907 void ECSClient::PutAccountSettingDefaultAsync(const PutAccountSettingDefaultRequest& request, const PutAccountSettingDefaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
908 {
909 m_executor->Submit( [this, request, handler, context](){ this->PutAccountSettingDefaultAsyncHelper( request, handler, context ); } );
910 }
911
PutAccountSettingDefaultAsyncHelper(const PutAccountSettingDefaultRequest & request,const PutAccountSettingDefaultResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const912 void ECSClient::PutAccountSettingDefaultAsyncHelper(const PutAccountSettingDefaultRequest& request, const PutAccountSettingDefaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
913 {
914 handler(this, request, PutAccountSettingDefault(request), context);
915 }
916
PutAttributes(const PutAttributesRequest & request) const917 PutAttributesOutcome ECSClient::PutAttributes(const PutAttributesRequest& request) const
918 {
919 Aws::Http::URI uri = m_uri;
920 return PutAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
921 }
922
PutAttributesCallable(const PutAttributesRequest & request) const923 PutAttributesOutcomeCallable ECSClient::PutAttributesCallable(const PutAttributesRequest& request) const
924 {
925 auto task = Aws::MakeShared< std::packaged_task< PutAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutAttributes(request); } );
926 auto packagedFunction = [task]() { (*task)(); };
927 m_executor->Submit(packagedFunction);
928 return task->get_future();
929 }
930
PutAttributesAsync(const PutAttributesRequest & request,const PutAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const931 void ECSClient::PutAttributesAsync(const PutAttributesRequest& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
932 {
933 m_executor->Submit( [this, request, handler, context](){ this->PutAttributesAsyncHelper( request, handler, context ); } );
934 }
935
PutAttributesAsyncHelper(const PutAttributesRequest & request,const PutAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const936 void ECSClient::PutAttributesAsyncHelper(const PutAttributesRequest& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
937 {
938 handler(this, request, PutAttributes(request), context);
939 }
940
PutClusterCapacityProviders(const PutClusterCapacityProvidersRequest & request) const941 PutClusterCapacityProvidersOutcome ECSClient::PutClusterCapacityProviders(const PutClusterCapacityProvidersRequest& request) const
942 {
943 Aws::Http::URI uri = m_uri;
944 return PutClusterCapacityProvidersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
945 }
946
PutClusterCapacityProvidersCallable(const PutClusterCapacityProvidersRequest & request) const947 PutClusterCapacityProvidersOutcomeCallable ECSClient::PutClusterCapacityProvidersCallable(const PutClusterCapacityProvidersRequest& request) const
948 {
949 auto task = Aws::MakeShared< std::packaged_task< PutClusterCapacityProvidersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutClusterCapacityProviders(request); } );
950 auto packagedFunction = [task]() { (*task)(); };
951 m_executor->Submit(packagedFunction);
952 return task->get_future();
953 }
954
PutClusterCapacityProvidersAsync(const PutClusterCapacityProvidersRequest & request,const PutClusterCapacityProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const955 void ECSClient::PutClusterCapacityProvidersAsync(const PutClusterCapacityProvidersRequest& request, const PutClusterCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
956 {
957 m_executor->Submit( [this, request, handler, context](){ this->PutClusterCapacityProvidersAsyncHelper( request, handler, context ); } );
958 }
959
PutClusterCapacityProvidersAsyncHelper(const PutClusterCapacityProvidersRequest & request,const PutClusterCapacityProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const960 void ECSClient::PutClusterCapacityProvidersAsyncHelper(const PutClusterCapacityProvidersRequest& request, const PutClusterCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
961 {
962 handler(this, request, PutClusterCapacityProviders(request), context);
963 }
964
RegisterContainerInstance(const RegisterContainerInstanceRequest & request) const965 RegisterContainerInstanceOutcome ECSClient::RegisterContainerInstance(const RegisterContainerInstanceRequest& request) const
966 {
967 Aws::Http::URI uri = m_uri;
968 return RegisterContainerInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
969 }
970
RegisterContainerInstanceCallable(const RegisterContainerInstanceRequest & request) const971 RegisterContainerInstanceOutcomeCallable ECSClient::RegisterContainerInstanceCallable(const RegisterContainerInstanceRequest& request) const
972 {
973 auto task = Aws::MakeShared< std::packaged_task< RegisterContainerInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RegisterContainerInstance(request); } );
974 auto packagedFunction = [task]() { (*task)(); };
975 m_executor->Submit(packagedFunction);
976 return task->get_future();
977 }
978
RegisterContainerInstanceAsync(const RegisterContainerInstanceRequest & request,const RegisterContainerInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const979 void ECSClient::RegisterContainerInstanceAsync(const RegisterContainerInstanceRequest& request, const RegisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
980 {
981 m_executor->Submit( [this, request, handler, context](){ this->RegisterContainerInstanceAsyncHelper( request, handler, context ); } );
982 }
983
RegisterContainerInstanceAsyncHelper(const RegisterContainerInstanceRequest & request,const RegisterContainerInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const984 void ECSClient::RegisterContainerInstanceAsyncHelper(const RegisterContainerInstanceRequest& request, const RegisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
985 {
986 handler(this, request, RegisterContainerInstance(request), context);
987 }
988
RegisterTaskDefinition(const RegisterTaskDefinitionRequest & request) const989 RegisterTaskDefinitionOutcome ECSClient::RegisterTaskDefinition(const RegisterTaskDefinitionRequest& request) const
990 {
991 Aws::Http::URI uri = m_uri;
992 return RegisterTaskDefinitionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
993 }
994
RegisterTaskDefinitionCallable(const RegisterTaskDefinitionRequest & request) const995 RegisterTaskDefinitionOutcomeCallable ECSClient::RegisterTaskDefinitionCallable(const RegisterTaskDefinitionRequest& request) const
996 {
997 auto task = Aws::MakeShared< std::packaged_task< RegisterTaskDefinitionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RegisterTaskDefinition(request); } );
998 auto packagedFunction = [task]() { (*task)(); };
999 m_executor->Submit(packagedFunction);
1000 return task->get_future();
1001 }
1002
RegisterTaskDefinitionAsync(const RegisterTaskDefinitionRequest & request,const RegisterTaskDefinitionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1003 void ECSClient::RegisterTaskDefinitionAsync(const RegisterTaskDefinitionRequest& request, const RegisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1004 {
1005 m_executor->Submit( [this, request, handler, context](){ this->RegisterTaskDefinitionAsyncHelper( request, handler, context ); } );
1006 }
1007
RegisterTaskDefinitionAsyncHelper(const RegisterTaskDefinitionRequest & request,const RegisterTaskDefinitionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1008 void ECSClient::RegisterTaskDefinitionAsyncHelper(const RegisterTaskDefinitionRequest& request, const RegisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1009 {
1010 handler(this, request, RegisterTaskDefinition(request), context);
1011 }
1012
RunTask(const RunTaskRequest & request) const1013 RunTaskOutcome ECSClient::RunTask(const RunTaskRequest& request) const
1014 {
1015 Aws::Http::URI uri = m_uri;
1016 return RunTaskOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1017 }
1018
RunTaskCallable(const RunTaskRequest & request) const1019 RunTaskOutcomeCallable ECSClient::RunTaskCallable(const RunTaskRequest& request) const
1020 {
1021 auto task = Aws::MakeShared< std::packaged_task< RunTaskOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RunTask(request); } );
1022 auto packagedFunction = [task]() { (*task)(); };
1023 m_executor->Submit(packagedFunction);
1024 return task->get_future();
1025 }
1026
RunTaskAsync(const RunTaskRequest & request,const RunTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1027 void ECSClient::RunTaskAsync(const RunTaskRequest& request, const RunTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1028 {
1029 m_executor->Submit( [this, request, handler, context](){ this->RunTaskAsyncHelper( request, handler, context ); } );
1030 }
1031
RunTaskAsyncHelper(const RunTaskRequest & request,const RunTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1032 void ECSClient::RunTaskAsyncHelper(const RunTaskRequest& request, const RunTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1033 {
1034 handler(this, request, RunTask(request), context);
1035 }
1036
StartTask(const StartTaskRequest & request) const1037 StartTaskOutcome ECSClient::StartTask(const StartTaskRequest& request) const
1038 {
1039 Aws::Http::URI uri = m_uri;
1040 return StartTaskOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1041 }
1042
StartTaskCallable(const StartTaskRequest & request) const1043 StartTaskOutcomeCallable ECSClient::StartTaskCallable(const StartTaskRequest& request) const
1044 {
1045 auto task = Aws::MakeShared< std::packaged_task< StartTaskOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartTask(request); } );
1046 auto packagedFunction = [task]() { (*task)(); };
1047 m_executor->Submit(packagedFunction);
1048 return task->get_future();
1049 }
1050
StartTaskAsync(const StartTaskRequest & request,const StartTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1051 void ECSClient::StartTaskAsync(const StartTaskRequest& request, const StartTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1052 {
1053 m_executor->Submit( [this, request, handler, context](){ this->StartTaskAsyncHelper( request, handler, context ); } );
1054 }
1055
StartTaskAsyncHelper(const StartTaskRequest & request,const StartTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1056 void ECSClient::StartTaskAsyncHelper(const StartTaskRequest& request, const StartTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1057 {
1058 handler(this, request, StartTask(request), context);
1059 }
1060
StopTask(const StopTaskRequest & request) const1061 StopTaskOutcome ECSClient::StopTask(const StopTaskRequest& request) const
1062 {
1063 Aws::Http::URI uri = m_uri;
1064 return StopTaskOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1065 }
1066
StopTaskCallable(const StopTaskRequest & request) const1067 StopTaskOutcomeCallable ECSClient::StopTaskCallable(const StopTaskRequest& request) const
1068 {
1069 auto task = Aws::MakeShared< std::packaged_task< StopTaskOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopTask(request); } );
1070 auto packagedFunction = [task]() { (*task)(); };
1071 m_executor->Submit(packagedFunction);
1072 return task->get_future();
1073 }
1074
StopTaskAsync(const StopTaskRequest & request,const StopTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1075 void ECSClient::StopTaskAsync(const StopTaskRequest& request, const StopTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1076 {
1077 m_executor->Submit( [this, request, handler, context](){ this->StopTaskAsyncHelper( request, handler, context ); } );
1078 }
1079
StopTaskAsyncHelper(const StopTaskRequest & request,const StopTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1080 void ECSClient::StopTaskAsyncHelper(const StopTaskRequest& request, const StopTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1081 {
1082 handler(this, request, StopTask(request), context);
1083 }
1084
SubmitAttachmentStateChanges(const SubmitAttachmentStateChangesRequest & request) const1085 SubmitAttachmentStateChangesOutcome ECSClient::SubmitAttachmentStateChanges(const SubmitAttachmentStateChangesRequest& request) const
1086 {
1087 Aws::Http::URI uri = m_uri;
1088 return SubmitAttachmentStateChangesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1089 }
1090
SubmitAttachmentStateChangesCallable(const SubmitAttachmentStateChangesRequest & request) const1091 SubmitAttachmentStateChangesOutcomeCallable ECSClient::SubmitAttachmentStateChangesCallable(const SubmitAttachmentStateChangesRequest& request) const
1092 {
1093 auto task = Aws::MakeShared< std::packaged_task< SubmitAttachmentStateChangesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SubmitAttachmentStateChanges(request); } );
1094 auto packagedFunction = [task]() { (*task)(); };
1095 m_executor->Submit(packagedFunction);
1096 return task->get_future();
1097 }
1098
SubmitAttachmentStateChangesAsync(const SubmitAttachmentStateChangesRequest & request,const SubmitAttachmentStateChangesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1099 void ECSClient::SubmitAttachmentStateChangesAsync(const SubmitAttachmentStateChangesRequest& request, const SubmitAttachmentStateChangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1100 {
1101 m_executor->Submit( [this, request, handler, context](){ this->SubmitAttachmentStateChangesAsyncHelper( request, handler, context ); } );
1102 }
1103
SubmitAttachmentStateChangesAsyncHelper(const SubmitAttachmentStateChangesRequest & request,const SubmitAttachmentStateChangesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1104 void ECSClient::SubmitAttachmentStateChangesAsyncHelper(const SubmitAttachmentStateChangesRequest& request, const SubmitAttachmentStateChangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1105 {
1106 handler(this, request, SubmitAttachmentStateChanges(request), context);
1107 }
1108
SubmitContainerStateChange(const SubmitContainerStateChangeRequest & request) const1109 SubmitContainerStateChangeOutcome ECSClient::SubmitContainerStateChange(const SubmitContainerStateChangeRequest& request) const
1110 {
1111 Aws::Http::URI uri = m_uri;
1112 return SubmitContainerStateChangeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1113 }
1114
SubmitContainerStateChangeCallable(const SubmitContainerStateChangeRequest & request) const1115 SubmitContainerStateChangeOutcomeCallable ECSClient::SubmitContainerStateChangeCallable(const SubmitContainerStateChangeRequest& request) const
1116 {
1117 auto task = Aws::MakeShared< std::packaged_task< SubmitContainerStateChangeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SubmitContainerStateChange(request); } );
1118 auto packagedFunction = [task]() { (*task)(); };
1119 m_executor->Submit(packagedFunction);
1120 return task->get_future();
1121 }
1122
SubmitContainerStateChangeAsync(const SubmitContainerStateChangeRequest & request,const SubmitContainerStateChangeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1123 void ECSClient::SubmitContainerStateChangeAsync(const SubmitContainerStateChangeRequest& request, const SubmitContainerStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1124 {
1125 m_executor->Submit( [this, request, handler, context](){ this->SubmitContainerStateChangeAsyncHelper( request, handler, context ); } );
1126 }
1127
SubmitContainerStateChangeAsyncHelper(const SubmitContainerStateChangeRequest & request,const SubmitContainerStateChangeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1128 void ECSClient::SubmitContainerStateChangeAsyncHelper(const SubmitContainerStateChangeRequest& request, const SubmitContainerStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1129 {
1130 handler(this, request, SubmitContainerStateChange(request), context);
1131 }
1132
SubmitTaskStateChange(const SubmitTaskStateChangeRequest & request) const1133 SubmitTaskStateChangeOutcome ECSClient::SubmitTaskStateChange(const SubmitTaskStateChangeRequest& request) const
1134 {
1135 Aws::Http::URI uri = m_uri;
1136 return SubmitTaskStateChangeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1137 }
1138
SubmitTaskStateChangeCallable(const SubmitTaskStateChangeRequest & request) const1139 SubmitTaskStateChangeOutcomeCallable ECSClient::SubmitTaskStateChangeCallable(const SubmitTaskStateChangeRequest& request) const
1140 {
1141 auto task = Aws::MakeShared< std::packaged_task< SubmitTaskStateChangeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SubmitTaskStateChange(request); } );
1142 auto packagedFunction = [task]() { (*task)(); };
1143 m_executor->Submit(packagedFunction);
1144 return task->get_future();
1145 }
1146
SubmitTaskStateChangeAsync(const SubmitTaskStateChangeRequest & request,const SubmitTaskStateChangeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1147 void ECSClient::SubmitTaskStateChangeAsync(const SubmitTaskStateChangeRequest& request, const SubmitTaskStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1148 {
1149 m_executor->Submit( [this, request, handler, context](){ this->SubmitTaskStateChangeAsyncHelper( request, handler, context ); } );
1150 }
1151
SubmitTaskStateChangeAsyncHelper(const SubmitTaskStateChangeRequest & request,const SubmitTaskStateChangeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1152 void ECSClient::SubmitTaskStateChangeAsyncHelper(const SubmitTaskStateChangeRequest& request, const SubmitTaskStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1153 {
1154 handler(this, request, SubmitTaskStateChange(request), context);
1155 }
1156
TagResource(const TagResourceRequest & request) const1157 TagResourceOutcome ECSClient::TagResource(const TagResourceRequest& request) const
1158 {
1159 Aws::Http::URI uri = m_uri;
1160 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1161 }
1162
TagResourceCallable(const TagResourceRequest & request) const1163 TagResourceOutcomeCallable ECSClient::TagResourceCallable(const TagResourceRequest& request) const
1164 {
1165 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1166 auto packagedFunction = [task]() { (*task)(); };
1167 m_executor->Submit(packagedFunction);
1168 return task->get_future();
1169 }
1170
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1171 void ECSClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1172 {
1173 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1174 }
1175
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1176 void ECSClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1177 {
1178 handler(this, request, TagResource(request), context);
1179 }
1180
UntagResource(const UntagResourceRequest & request) const1181 UntagResourceOutcome ECSClient::UntagResource(const UntagResourceRequest& request) const
1182 {
1183 Aws::Http::URI uri = m_uri;
1184 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1185 }
1186
UntagResourceCallable(const UntagResourceRequest & request) const1187 UntagResourceOutcomeCallable ECSClient::UntagResourceCallable(const UntagResourceRequest& request) const
1188 {
1189 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1190 auto packagedFunction = [task]() { (*task)(); };
1191 m_executor->Submit(packagedFunction);
1192 return task->get_future();
1193 }
1194
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1195 void ECSClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1196 {
1197 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1198 }
1199
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1200 void ECSClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1201 {
1202 handler(this, request, UntagResource(request), context);
1203 }
1204
UpdateCapacityProvider(const UpdateCapacityProviderRequest & request) const1205 UpdateCapacityProviderOutcome ECSClient::UpdateCapacityProvider(const UpdateCapacityProviderRequest& request) const
1206 {
1207 Aws::Http::URI uri = m_uri;
1208 return UpdateCapacityProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1209 }
1210
UpdateCapacityProviderCallable(const UpdateCapacityProviderRequest & request) const1211 UpdateCapacityProviderOutcomeCallable ECSClient::UpdateCapacityProviderCallable(const UpdateCapacityProviderRequest& request) const
1212 {
1213 auto task = Aws::MakeShared< std::packaged_task< UpdateCapacityProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateCapacityProvider(request); } );
1214 auto packagedFunction = [task]() { (*task)(); };
1215 m_executor->Submit(packagedFunction);
1216 return task->get_future();
1217 }
1218
UpdateCapacityProviderAsync(const UpdateCapacityProviderRequest & request,const UpdateCapacityProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1219 void ECSClient::UpdateCapacityProviderAsync(const UpdateCapacityProviderRequest& request, const UpdateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1220 {
1221 m_executor->Submit( [this, request, handler, context](){ this->UpdateCapacityProviderAsyncHelper( request, handler, context ); } );
1222 }
1223
UpdateCapacityProviderAsyncHelper(const UpdateCapacityProviderRequest & request,const UpdateCapacityProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1224 void ECSClient::UpdateCapacityProviderAsyncHelper(const UpdateCapacityProviderRequest& request, const UpdateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1225 {
1226 handler(this, request, UpdateCapacityProvider(request), context);
1227 }
1228
UpdateCluster(const UpdateClusterRequest & request) const1229 UpdateClusterOutcome ECSClient::UpdateCluster(const UpdateClusterRequest& request) const
1230 {
1231 Aws::Http::URI uri = m_uri;
1232 return UpdateClusterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1233 }
1234
UpdateClusterCallable(const UpdateClusterRequest & request) const1235 UpdateClusterOutcomeCallable ECSClient::UpdateClusterCallable(const UpdateClusterRequest& request) const
1236 {
1237 auto task = Aws::MakeShared< std::packaged_task< UpdateClusterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateCluster(request); } );
1238 auto packagedFunction = [task]() { (*task)(); };
1239 m_executor->Submit(packagedFunction);
1240 return task->get_future();
1241 }
1242
UpdateClusterAsync(const UpdateClusterRequest & request,const UpdateClusterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1243 void ECSClient::UpdateClusterAsync(const UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1244 {
1245 m_executor->Submit( [this, request, handler, context](){ this->UpdateClusterAsyncHelper( request, handler, context ); } );
1246 }
1247
UpdateClusterAsyncHelper(const UpdateClusterRequest & request,const UpdateClusterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1248 void ECSClient::UpdateClusterAsyncHelper(const UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1249 {
1250 handler(this, request, UpdateCluster(request), context);
1251 }
1252
UpdateClusterSettings(const UpdateClusterSettingsRequest & request) const1253 UpdateClusterSettingsOutcome ECSClient::UpdateClusterSettings(const UpdateClusterSettingsRequest& request) const
1254 {
1255 Aws::Http::URI uri = m_uri;
1256 return UpdateClusterSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1257 }
1258
UpdateClusterSettingsCallable(const UpdateClusterSettingsRequest & request) const1259 UpdateClusterSettingsOutcomeCallable ECSClient::UpdateClusterSettingsCallable(const UpdateClusterSettingsRequest& request) const
1260 {
1261 auto task = Aws::MakeShared< std::packaged_task< UpdateClusterSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateClusterSettings(request); } );
1262 auto packagedFunction = [task]() { (*task)(); };
1263 m_executor->Submit(packagedFunction);
1264 return task->get_future();
1265 }
1266
UpdateClusterSettingsAsync(const UpdateClusterSettingsRequest & request,const UpdateClusterSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1267 void ECSClient::UpdateClusterSettingsAsync(const UpdateClusterSettingsRequest& request, const UpdateClusterSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1268 {
1269 m_executor->Submit( [this, request, handler, context](){ this->UpdateClusterSettingsAsyncHelper( request, handler, context ); } );
1270 }
1271
UpdateClusterSettingsAsyncHelper(const UpdateClusterSettingsRequest & request,const UpdateClusterSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1272 void ECSClient::UpdateClusterSettingsAsyncHelper(const UpdateClusterSettingsRequest& request, const UpdateClusterSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1273 {
1274 handler(this, request, UpdateClusterSettings(request), context);
1275 }
1276
UpdateContainerAgent(const UpdateContainerAgentRequest & request) const1277 UpdateContainerAgentOutcome ECSClient::UpdateContainerAgent(const UpdateContainerAgentRequest& request) const
1278 {
1279 Aws::Http::URI uri = m_uri;
1280 return UpdateContainerAgentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1281 }
1282
UpdateContainerAgentCallable(const UpdateContainerAgentRequest & request) const1283 UpdateContainerAgentOutcomeCallable ECSClient::UpdateContainerAgentCallable(const UpdateContainerAgentRequest& request) const
1284 {
1285 auto task = Aws::MakeShared< std::packaged_task< UpdateContainerAgentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateContainerAgent(request); } );
1286 auto packagedFunction = [task]() { (*task)(); };
1287 m_executor->Submit(packagedFunction);
1288 return task->get_future();
1289 }
1290
UpdateContainerAgentAsync(const UpdateContainerAgentRequest & request,const UpdateContainerAgentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1291 void ECSClient::UpdateContainerAgentAsync(const UpdateContainerAgentRequest& request, const UpdateContainerAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1292 {
1293 m_executor->Submit( [this, request, handler, context](){ this->UpdateContainerAgentAsyncHelper( request, handler, context ); } );
1294 }
1295
UpdateContainerAgentAsyncHelper(const UpdateContainerAgentRequest & request,const UpdateContainerAgentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1296 void ECSClient::UpdateContainerAgentAsyncHelper(const UpdateContainerAgentRequest& request, const UpdateContainerAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1297 {
1298 handler(this, request, UpdateContainerAgent(request), context);
1299 }
1300
UpdateContainerInstancesState(const UpdateContainerInstancesStateRequest & request) const1301 UpdateContainerInstancesStateOutcome ECSClient::UpdateContainerInstancesState(const UpdateContainerInstancesStateRequest& request) const
1302 {
1303 Aws::Http::URI uri = m_uri;
1304 return UpdateContainerInstancesStateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1305 }
1306
UpdateContainerInstancesStateCallable(const UpdateContainerInstancesStateRequest & request) const1307 UpdateContainerInstancesStateOutcomeCallable ECSClient::UpdateContainerInstancesStateCallable(const UpdateContainerInstancesStateRequest& request) const
1308 {
1309 auto task = Aws::MakeShared< std::packaged_task< UpdateContainerInstancesStateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateContainerInstancesState(request); } );
1310 auto packagedFunction = [task]() { (*task)(); };
1311 m_executor->Submit(packagedFunction);
1312 return task->get_future();
1313 }
1314
UpdateContainerInstancesStateAsync(const UpdateContainerInstancesStateRequest & request,const UpdateContainerInstancesStateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1315 void ECSClient::UpdateContainerInstancesStateAsync(const UpdateContainerInstancesStateRequest& request, const UpdateContainerInstancesStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1316 {
1317 m_executor->Submit( [this, request, handler, context](){ this->UpdateContainerInstancesStateAsyncHelper( request, handler, context ); } );
1318 }
1319
UpdateContainerInstancesStateAsyncHelper(const UpdateContainerInstancesStateRequest & request,const UpdateContainerInstancesStateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1320 void ECSClient::UpdateContainerInstancesStateAsyncHelper(const UpdateContainerInstancesStateRequest& request, const UpdateContainerInstancesStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1321 {
1322 handler(this, request, UpdateContainerInstancesState(request), context);
1323 }
1324
UpdateService(const UpdateServiceRequest & request) const1325 UpdateServiceOutcome ECSClient::UpdateService(const UpdateServiceRequest& request) const
1326 {
1327 Aws::Http::URI uri = m_uri;
1328 return UpdateServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1329 }
1330
UpdateServiceCallable(const UpdateServiceRequest & request) const1331 UpdateServiceOutcomeCallable ECSClient::UpdateServiceCallable(const UpdateServiceRequest& request) const
1332 {
1333 auto task = Aws::MakeShared< std::packaged_task< UpdateServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateService(request); } );
1334 auto packagedFunction = [task]() { (*task)(); };
1335 m_executor->Submit(packagedFunction);
1336 return task->get_future();
1337 }
1338
UpdateServiceAsync(const UpdateServiceRequest & request,const UpdateServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1339 void ECSClient::UpdateServiceAsync(const UpdateServiceRequest& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1340 {
1341 m_executor->Submit( [this, request, handler, context](){ this->UpdateServiceAsyncHelper( request, handler, context ); } );
1342 }
1343
UpdateServiceAsyncHelper(const UpdateServiceRequest & request,const UpdateServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1344 void ECSClient::UpdateServiceAsyncHelper(const UpdateServiceRequest& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1345 {
1346 handler(this, request, UpdateService(request), context);
1347 }
1348
UpdateServicePrimaryTaskSet(const UpdateServicePrimaryTaskSetRequest & request) const1349 UpdateServicePrimaryTaskSetOutcome ECSClient::UpdateServicePrimaryTaskSet(const UpdateServicePrimaryTaskSetRequest& request) const
1350 {
1351 Aws::Http::URI uri = m_uri;
1352 return UpdateServicePrimaryTaskSetOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1353 }
1354
UpdateServicePrimaryTaskSetCallable(const UpdateServicePrimaryTaskSetRequest & request) const1355 UpdateServicePrimaryTaskSetOutcomeCallable ECSClient::UpdateServicePrimaryTaskSetCallable(const UpdateServicePrimaryTaskSetRequest& request) const
1356 {
1357 auto task = Aws::MakeShared< std::packaged_task< UpdateServicePrimaryTaskSetOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateServicePrimaryTaskSet(request); } );
1358 auto packagedFunction = [task]() { (*task)(); };
1359 m_executor->Submit(packagedFunction);
1360 return task->get_future();
1361 }
1362
UpdateServicePrimaryTaskSetAsync(const UpdateServicePrimaryTaskSetRequest & request,const UpdateServicePrimaryTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1363 void ECSClient::UpdateServicePrimaryTaskSetAsync(const UpdateServicePrimaryTaskSetRequest& request, const UpdateServicePrimaryTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1364 {
1365 m_executor->Submit( [this, request, handler, context](){ this->UpdateServicePrimaryTaskSetAsyncHelper( request, handler, context ); } );
1366 }
1367
UpdateServicePrimaryTaskSetAsyncHelper(const UpdateServicePrimaryTaskSetRequest & request,const UpdateServicePrimaryTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1368 void ECSClient::UpdateServicePrimaryTaskSetAsyncHelper(const UpdateServicePrimaryTaskSetRequest& request, const UpdateServicePrimaryTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1369 {
1370 handler(this, request, UpdateServicePrimaryTaskSet(request), context);
1371 }
1372
UpdateTaskSet(const UpdateTaskSetRequest & request) const1373 UpdateTaskSetOutcome ECSClient::UpdateTaskSet(const UpdateTaskSetRequest& request) const
1374 {
1375 Aws::Http::URI uri = m_uri;
1376 return UpdateTaskSetOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1377 }
1378
UpdateTaskSetCallable(const UpdateTaskSetRequest & request) const1379 UpdateTaskSetOutcomeCallable ECSClient::UpdateTaskSetCallable(const UpdateTaskSetRequest& request) const
1380 {
1381 auto task = Aws::MakeShared< std::packaged_task< UpdateTaskSetOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateTaskSet(request); } );
1382 auto packagedFunction = [task]() { (*task)(); };
1383 m_executor->Submit(packagedFunction);
1384 return task->get_future();
1385 }
1386
UpdateTaskSetAsync(const UpdateTaskSetRequest & request,const UpdateTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1387 void ECSClient::UpdateTaskSetAsync(const UpdateTaskSetRequest& request, const UpdateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1388 {
1389 m_executor->Submit( [this, request, handler, context](){ this->UpdateTaskSetAsyncHelper( request, handler, context ); } );
1390 }
1391
UpdateTaskSetAsyncHelper(const UpdateTaskSetRequest & request,const UpdateTaskSetResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1392 void ECSClient::UpdateTaskSetAsyncHelper(const UpdateTaskSetRequest& request, const UpdateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1393 {
1394 handler(this, request, UpdateTaskSet(request), context);
1395 }
1396
1397