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/appmesh/AppMeshClient.h>
21 #include <aws/appmesh/AppMeshEndpoint.h>
22 #include <aws/appmesh/AppMeshErrorMarshaller.h>
23 #include <aws/appmesh/model/CreateGatewayRouteRequest.h>
24 #include <aws/appmesh/model/CreateMeshRequest.h>
25 #include <aws/appmesh/model/CreateRouteRequest.h>
26 #include <aws/appmesh/model/CreateVirtualGatewayRequest.h>
27 #include <aws/appmesh/model/CreateVirtualNodeRequest.h>
28 #include <aws/appmesh/model/CreateVirtualRouterRequest.h>
29 #include <aws/appmesh/model/CreateVirtualServiceRequest.h>
30 #include <aws/appmesh/model/DeleteGatewayRouteRequest.h>
31 #include <aws/appmesh/model/DeleteMeshRequest.h>
32 #include <aws/appmesh/model/DeleteRouteRequest.h>
33 #include <aws/appmesh/model/DeleteVirtualGatewayRequest.h>
34 #include <aws/appmesh/model/DeleteVirtualNodeRequest.h>
35 #include <aws/appmesh/model/DeleteVirtualRouterRequest.h>
36 #include <aws/appmesh/model/DeleteVirtualServiceRequest.h>
37 #include <aws/appmesh/model/DescribeGatewayRouteRequest.h>
38 #include <aws/appmesh/model/DescribeMeshRequest.h>
39 #include <aws/appmesh/model/DescribeRouteRequest.h>
40 #include <aws/appmesh/model/DescribeVirtualGatewayRequest.h>
41 #include <aws/appmesh/model/DescribeVirtualNodeRequest.h>
42 #include <aws/appmesh/model/DescribeVirtualRouterRequest.h>
43 #include <aws/appmesh/model/DescribeVirtualServiceRequest.h>
44 #include <aws/appmesh/model/ListGatewayRoutesRequest.h>
45 #include <aws/appmesh/model/ListMeshesRequest.h>
46 #include <aws/appmesh/model/ListRoutesRequest.h>
47 #include <aws/appmesh/model/ListTagsForResourceRequest.h>
48 #include <aws/appmesh/model/ListVirtualGatewaysRequest.h>
49 #include <aws/appmesh/model/ListVirtualNodesRequest.h>
50 #include <aws/appmesh/model/ListVirtualRoutersRequest.h>
51 #include <aws/appmesh/model/ListVirtualServicesRequest.h>
52 #include <aws/appmesh/model/TagResourceRequest.h>
53 #include <aws/appmesh/model/UntagResourceRequest.h>
54 #include <aws/appmesh/model/UpdateGatewayRouteRequest.h>
55 #include <aws/appmesh/model/UpdateMeshRequest.h>
56 #include <aws/appmesh/model/UpdateRouteRequest.h>
57 #include <aws/appmesh/model/UpdateVirtualGatewayRequest.h>
58 #include <aws/appmesh/model/UpdateVirtualNodeRequest.h>
59 #include <aws/appmesh/model/UpdateVirtualRouterRequest.h>
60 #include <aws/appmesh/model/UpdateVirtualServiceRequest.h>
61
62 using namespace Aws;
63 using namespace Aws::Auth;
64 using namespace Aws::Client;
65 using namespace Aws::AppMesh;
66 using namespace Aws::AppMesh::Model;
67 using namespace Aws::Http;
68 using namespace Aws::Utils::Json;
69
70 static const char* SERVICE_NAME = "appmesh";
71 static const char* ALLOCATION_TAG = "AppMeshClient";
72
73
AppMeshClient(const Client::ClientConfiguration & clientConfiguration)74 AppMeshClient::AppMeshClient(const Client::ClientConfiguration& clientConfiguration) :
75 BASECLASS(clientConfiguration,
76 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
77 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
78 Aws::MakeShared<AppMeshErrorMarshaller>(ALLOCATION_TAG)),
79 m_executor(clientConfiguration.executor)
80 {
81 init(clientConfiguration);
82 }
83
AppMeshClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)84 AppMeshClient::AppMeshClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
85 BASECLASS(clientConfiguration,
86 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
87 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
88 Aws::MakeShared<AppMeshErrorMarshaller>(ALLOCATION_TAG)),
89 m_executor(clientConfiguration.executor)
90 {
91 init(clientConfiguration);
92 }
93
AppMeshClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)94 AppMeshClient::AppMeshClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
95 const Client::ClientConfiguration& clientConfiguration) :
96 BASECLASS(clientConfiguration,
97 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
98 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
99 Aws::MakeShared<AppMeshErrorMarshaller>(ALLOCATION_TAG)),
100 m_executor(clientConfiguration.executor)
101 {
102 init(clientConfiguration);
103 }
104
~AppMeshClient()105 AppMeshClient::~AppMeshClient()
106 {
107 }
108
init(const Client::ClientConfiguration & config)109 void AppMeshClient::init(const Client::ClientConfiguration& config)
110 {
111 SetServiceClientName("App Mesh");
112 m_configScheme = SchemeMapper::ToString(config.scheme);
113 if (config.endpointOverride.empty())
114 {
115 m_uri = m_configScheme + "://" + AppMeshEndpoint::ForRegion(config.region, config.useDualStack);
116 }
117 else
118 {
119 OverrideEndpoint(config.endpointOverride);
120 }
121 }
122
OverrideEndpoint(const Aws::String & endpoint)123 void AppMeshClient::OverrideEndpoint(const Aws::String& endpoint)
124 {
125 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
126 {
127 m_uri = endpoint;
128 }
129 else
130 {
131 m_uri = m_configScheme + "://" + endpoint;
132 }
133 }
134
CreateGatewayRoute(const CreateGatewayRouteRequest & request) const135 CreateGatewayRouteOutcome AppMeshClient::CreateGatewayRoute(const CreateGatewayRouteRequest& request) const
136 {
137 if (!request.MeshNameHasBeenSet())
138 {
139 AWS_LOGSTREAM_ERROR("CreateGatewayRoute", "Required field: MeshName, is not set");
140 return CreateGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
141 }
142 if (!request.VirtualGatewayNameHasBeenSet())
143 {
144 AWS_LOGSTREAM_ERROR("CreateGatewayRoute", "Required field: VirtualGatewayName, is not set");
145 return CreateGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
146 }
147 Aws::Http::URI uri = m_uri;
148 uri.AddPathSegments("/v20190125/meshes/");
149 uri.AddPathSegment(request.GetMeshName());
150 uri.AddPathSegments("/virtualGateway/");
151 uri.AddPathSegment(request.GetVirtualGatewayName());
152 uri.AddPathSegments("/gatewayRoutes");
153 return CreateGatewayRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
154 }
155
CreateGatewayRouteCallable(const CreateGatewayRouteRequest & request) const156 CreateGatewayRouteOutcomeCallable AppMeshClient::CreateGatewayRouteCallable(const CreateGatewayRouteRequest& request) const
157 {
158 auto task = Aws::MakeShared< std::packaged_task< CreateGatewayRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateGatewayRoute(request); } );
159 auto packagedFunction = [task]() { (*task)(); };
160 m_executor->Submit(packagedFunction);
161 return task->get_future();
162 }
163
CreateGatewayRouteAsync(const CreateGatewayRouteRequest & request,const CreateGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const164 void AppMeshClient::CreateGatewayRouteAsync(const CreateGatewayRouteRequest& request, const CreateGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
165 {
166 m_executor->Submit( [this, request, handler, context](){ this->CreateGatewayRouteAsyncHelper( request, handler, context ); } );
167 }
168
CreateGatewayRouteAsyncHelper(const CreateGatewayRouteRequest & request,const CreateGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const169 void AppMeshClient::CreateGatewayRouteAsyncHelper(const CreateGatewayRouteRequest& request, const CreateGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
170 {
171 handler(this, request, CreateGatewayRoute(request), context);
172 }
173
CreateMesh(const CreateMeshRequest & request) const174 CreateMeshOutcome AppMeshClient::CreateMesh(const CreateMeshRequest& request) const
175 {
176 Aws::Http::URI uri = m_uri;
177 uri.AddPathSegments("/v20190125/meshes");
178 return CreateMeshOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
179 }
180
CreateMeshCallable(const CreateMeshRequest & request) const181 CreateMeshOutcomeCallable AppMeshClient::CreateMeshCallable(const CreateMeshRequest& request) const
182 {
183 auto task = Aws::MakeShared< std::packaged_task< CreateMeshOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMesh(request); } );
184 auto packagedFunction = [task]() { (*task)(); };
185 m_executor->Submit(packagedFunction);
186 return task->get_future();
187 }
188
CreateMeshAsync(const CreateMeshRequest & request,const CreateMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const189 void AppMeshClient::CreateMeshAsync(const CreateMeshRequest& request, const CreateMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
190 {
191 m_executor->Submit( [this, request, handler, context](){ this->CreateMeshAsyncHelper( request, handler, context ); } );
192 }
193
CreateMeshAsyncHelper(const CreateMeshRequest & request,const CreateMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const194 void AppMeshClient::CreateMeshAsyncHelper(const CreateMeshRequest& request, const CreateMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
195 {
196 handler(this, request, CreateMesh(request), context);
197 }
198
CreateRoute(const CreateRouteRequest & request) const199 CreateRouteOutcome AppMeshClient::CreateRoute(const CreateRouteRequest& request) const
200 {
201 if (!request.MeshNameHasBeenSet())
202 {
203 AWS_LOGSTREAM_ERROR("CreateRoute", "Required field: MeshName, is not set");
204 return CreateRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
205 }
206 if (!request.VirtualRouterNameHasBeenSet())
207 {
208 AWS_LOGSTREAM_ERROR("CreateRoute", "Required field: VirtualRouterName, is not set");
209 return CreateRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
210 }
211 Aws::Http::URI uri = m_uri;
212 uri.AddPathSegments("/v20190125/meshes/");
213 uri.AddPathSegment(request.GetMeshName());
214 uri.AddPathSegments("/virtualRouter/");
215 uri.AddPathSegment(request.GetVirtualRouterName());
216 uri.AddPathSegments("/routes");
217 return CreateRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
218 }
219
CreateRouteCallable(const CreateRouteRequest & request) const220 CreateRouteOutcomeCallable AppMeshClient::CreateRouteCallable(const CreateRouteRequest& request) const
221 {
222 auto task = Aws::MakeShared< std::packaged_task< CreateRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateRoute(request); } );
223 auto packagedFunction = [task]() { (*task)(); };
224 m_executor->Submit(packagedFunction);
225 return task->get_future();
226 }
227
CreateRouteAsync(const CreateRouteRequest & request,const CreateRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const228 void AppMeshClient::CreateRouteAsync(const CreateRouteRequest& request, const CreateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
229 {
230 m_executor->Submit( [this, request, handler, context](){ this->CreateRouteAsyncHelper( request, handler, context ); } );
231 }
232
CreateRouteAsyncHelper(const CreateRouteRequest & request,const CreateRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const233 void AppMeshClient::CreateRouteAsyncHelper(const CreateRouteRequest& request, const CreateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
234 {
235 handler(this, request, CreateRoute(request), context);
236 }
237
CreateVirtualGateway(const CreateVirtualGatewayRequest & request) const238 CreateVirtualGatewayOutcome AppMeshClient::CreateVirtualGateway(const CreateVirtualGatewayRequest& request) const
239 {
240 if (!request.MeshNameHasBeenSet())
241 {
242 AWS_LOGSTREAM_ERROR("CreateVirtualGateway", "Required field: MeshName, is not set");
243 return CreateVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
244 }
245 Aws::Http::URI uri = m_uri;
246 uri.AddPathSegments("/v20190125/meshes/");
247 uri.AddPathSegment(request.GetMeshName());
248 uri.AddPathSegments("/virtualGateways");
249 return CreateVirtualGatewayOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
250 }
251
CreateVirtualGatewayCallable(const CreateVirtualGatewayRequest & request) const252 CreateVirtualGatewayOutcomeCallable AppMeshClient::CreateVirtualGatewayCallable(const CreateVirtualGatewayRequest& request) const
253 {
254 auto task = Aws::MakeShared< std::packaged_task< CreateVirtualGatewayOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVirtualGateway(request); } );
255 auto packagedFunction = [task]() { (*task)(); };
256 m_executor->Submit(packagedFunction);
257 return task->get_future();
258 }
259
CreateVirtualGatewayAsync(const CreateVirtualGatewayRequest & request,const CreateVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const260 void AppMeshClient::CreateVirtualGatewayAsync(const CreateVirtualGatewayRequest& request, const CreateVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
261 {
262 m_executor->Submit( [this, request, handler, context](){ this->CreateVirtualGatewayAsyncHelper( request, handler, context ); } );
263 }
264
CreateVirtualGatewayAsyncHelper(const CreateVirtualGatewayRequest & request,const CreateVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const265 void AppMeshClient::CreateVirtualGatewayAsyncHelper(const CreateVirtualGatewayRequest& request, const CreateVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
266 {
267 handler(this, request, CreateVirtualGateway(request), context);
268 }
269
CreateVirtualNode(const CreateVirtualNodeRequest & request) const270 CreateVirtualNodeOutcome AppMeshClient::CreateVirtualNode(const CreateVirtualNodeRequest& request) const
271 {
272 if (!request.MeshNameHasBeenSet())
273 {
274 AWS_LOGSTREAM_ERROR("CreateVirtualNode", "Required field: MeshName, is not set");
275 return CreateVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
276 }
277 Aws::Http::URI uri = m_uri;
278 uri.AddPathSegments("/v20190125/meshes/");
279 uri.AddPathSegment(request.GetMeshName());
280 uri.AddPathSegments("/virtualNodes");
281 return CreateVirtualNodeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
282 }
283
CreateVirtualNodeCallable(const CreateVirtualNodeRequest & request) const284 CreateVirtualNodeOutcomeCallable AppMeshClient::CreateVirtualNodeCallable(const CreateVirtualNodeRequest& request) const
285 {
286 auto task = Aws::MakeShared< std::packaged_task< CreateVirtualNodeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVirtualNode(request); } );
287 auto packagedFunction = [task]() { (*task)(); };
288 m_executor->Submit(packagedFunction);
289 return task->get_future();
290 }
291
CreateVirtualNodeAsync(const CreateVirtualNodeRequest & request,const CreateVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const292 void AppMeshClient::CreateVirtualNodeAsync(const CreateVirtualNodeRequest& request, const CreateVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
293 {
294 m_executor->Submit( [this, request, handler, context](){ this->CreateVirtualNodeAsyncHelper( request, handler, context ); } );
295 }
296
CreateVirtualNodeAsyncHelper(const CreateVirtualNodeRequest & request,const CreateVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const297 void AppMeshClient::CreateVirtualNodeAsyncHelper(const CreateVirtualNodeRequest& request, const CreateVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
298 {
299 handler(this, request, CreateVirtualNode(request), context);
300 }
301
CreateVirtualRouter(const CreateVirtualRouterRequest & request) const302 CreateVirtualRouterOutcome AppMeshClient::CreateVirtualRouter(const CreateVirtualRouterRequest& request) const
303 {
304 if (!request.MeshNameHasBeenSet())
305 {
306 AWS_LOGSTREAM_ERROR("CreateVirtualRouter", "Required field: MeshName, is not set");
307 return CreateVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
308 }
309 Aws::Http::URI uri = m_uri;
310 uri.AddPathSegments("/v20190125/meshes/");
311 uri.AddPathSegment(request.GetMeshName());
312 uri.AddPathSegments("/virtualRouters");
313 return CreateVirtualRouterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
314 }
315
CreateVirtualRouterCallable(const CreateVirtualRouterRequest & request) const316 CreateVirtualRouterOutcomeCallable AppMeshClient::CreateVirtualRouterCallable(const CreateVirtualRouterRequest& request) const
317 {
318 auto task = Aws::MakeShared< std::packaged_task< CreateVirtualRouterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVirtualRouter(request); } );
319 auto packagedFunction = [task]() { (*task)(); };
320 m_executor->Submit(packagedFunction);
321 return task->get_future();
322 }
323
CreateVirtualRouterAsync(const CreateVirtualRouterRequest & request,const CreateVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const324 void AppMeshClient::CreateVirtualRouterAsync(const CreateVirtualRouterRequest& request, const CreateVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
325 {
326 m_executor->Submit( [this, request, handler, context](){ this->CreateVirtualRouterAsyncHelper( request, handler, context ); } );
327 }
328
CreateVirtualRouterAsyncHelper(const CreateVirtualRouterRequest & request,const CreateVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const329 void AppMeshClient::CreateVirtualRouterAsyncHelper(const CreateVirtualRouterRequest& request, const CreateVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
330 {
331 handler(this, request, CreateVirtualRouter(request), context);
332 }
333
CreateVirtualService(const CreateVirtualServiceRequest & request) const334 CreateVirtualServiceOutcome AppMeshClient::CreateVirtualService(const CreateVirtualServiceRequest& request) const
335 {
336 if (!request.MeshNameHasBeenSet())
337 {
338 AWS_LOGSTREAM_ERROR("CreateVirtualService", "Required field: MeshName, is not set");
339 return CreateVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
340 }
341 Aws::Http::URI uri = m_uri;
342 uri.AddPathSegments("/v20190125/meshes/");
343 uri.AddPathSegment(request.GetMeshName());
344 uri.AddPathSegments("/virtualServices");
345 return CreateVirtualServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
346 }
347
CreateVirtualServiceCallable(const CreateVirtualServiceRequest & request) const348 CreateVirtualServiceOutcomeCallable AppMeshClient::CreateVirtualServiceCallable(const CreateVirtualServiceRequest& request) const
349 {
350 auto task = Aws::MakeShared< std::packaged_task< CreateVirtualServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVirtualService(request); } );
351 auto packagedFunction = [task]() { (*task)(); };
352 m_executor->Submit(packagedFunction);
353 return task->get_future();
354 }
355
CreateVirtualServiceAsync(const CreateVirtualServiceRequest & request,const CreateVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const356 void AppMeshClient::CreateVirtualServiceAsync(const CreateVirtualServiceRequest& request, const CreateVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
357 {
358 m_executor->Submit( [this, request, handler, context](){ this->CreateVirtualServiceAsyncHelper( request, handler, context ); } );
359 }
360
CreateVirtualServiceAsyncHelper(const CreateVirtualServiceRequest & request,const CreateVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const361 void AppMeshClient::CreateVirtualServiceAsyncHelper(const CreateVirtualServiceRequest& request, const CreateVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
362 {
363 handler(this, request, CreateVirtualService(request), context);
364 }
365
DeleteGatewayRoute(const DeleteGatewayRouteRequest & request) const366 DeleteGatewayRouteOutcome AppMeshClient::DeleteGatewayRoute(const DeleteGatewayRouteRequest& request) const
367 {
368 if (!request.GatewayRouteNameHasBeenSet())
369 {
370 AWS_LOGSTREAM_ERROR("DeleteGatewayRoute", "Required field: GatewayRouteName, is not set");
371 return DeleteGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [GatewayRouteName]", false));
372 }
373 if (!request.MeshNameHasBeenSet())
374 {
375 AWS_LOGSTREAM_ERROR("DeleteGatewayRoute", "Required field: MeshName, is not set");
376 return DeleteGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
377 }
378 if (!request.VirtualGatewayNameHasBeenSet())
379 {
380 AWS_LOGSTREAM_ERROR("DeleteGatewayRoute", "Required field: VirtualGatewayName, is not set");
381 return DeleteGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
382 }
383 Aws::Http::URI uri = m_uri;
384 uri.AddPathSegments("/v20190125/meshes/");
385 uri.AddPathSegment(request.GetMeshName());
386 uri.AddPathSegments("/virtualGateway/");
387 uri.AddPathSegment(request.GetVirtualGatewayName());
388 uri.AddPathSegments("/gatewayRoutes/");
389 uri.AddPathSegment(request.GetGatewayRouteName());
390 return DeleteGatewayRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
391 }
392
DeleteGatewayRouteCallable(const DeleteGatewayRouteRequest & request) const393 DeleteGatewayRouteOutcomeCallable AppMeshClient::DeleteGatewayRouteCallable(const DeleteGatewayRouteRequest& request) const
394 {
395 auto task = Aws::MakeShared< std::packaged_task< DeleteGatewayRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteGatewayRoute(request); } );
396 auto packagedFunction = [task]() { (*task)(); };
397 m_executor->Submit(packagedFunction);
398 return task->get_future();
399 }
400
DeleteGatewayRouteAsync(const DeleteGatewayRouteRequest & request,const DeleteGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const401 void AppMeshClient::DeleteGatewayRouteAsync(const DeleteGatewayRouteRequest& request, const DeleteGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
402 {
403 m_executor->Submit( [this, request, handler, context](){ this->DeleteGatewayRouteAsyncHelper( request, handler, context ); } );
404 }
405
DeleteGatewayRouteAsyncHelper(const DeleteGatewayRouteRequest & request,const DeleteGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const406 void AppMeshClient::DeleteGatewayRouteAsyncHelper(const DeleteGatewayRouteRequest& request, const DeleteGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
407 {
408 handler(this, request, DeleteGatewayRoute(request), context);
409 }
410
DeleteMesh(const DeleteMeshRequest & request) const411 DeleteMeshOutcome AppMeshClient::DeleteMesh(const DeleteMeshRequest& request) const
412 {
413 if (!request.MeshNameHasBeenSet())
414 {
415 AWS_LOGSTREAM_ERROR("DeleteMesh", "Required field: MeshName, is not set");
416 return DeleteMeshOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
417 }
418 Aws::Http::URI uri = m_uri;
419 uri.AddPathSegments("/v20190125/meshes/");
420 uri.AddPathSegment(request.GetMeshName());
421 return DeleteMeshOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
422 }
423
DeleteMeshCallable(const DeleteMeshRequest & request) const424 DeleteMeshOutcomeCallable AppMeshClient::DeleteMeshCallable(const DeleteMeshRequest& request) const
425 {
426 auto task = Aws::MakeShared< std::packaged_task< DeleteMeshOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteMesh(request); } );
427 auto packagedFunction = [task]() { (*task)(); };
428 m_executor->Submit(packagedFunction);
429 return task->get_future();
430 }
431
DeleteMeshAsync(const DeleteMeshRequest & request,const DeleteMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const432 void AppMeshClient::DeleteMeshAsync(const DeleteMeshRequest& request, const DeleteMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
433 {
434 m_executor->Submit( [this, request, handler, context](){ this->DeleteMeshAsyncHelper( request, handler, context ); } );
435 }
436
DeleteMeshAsyncHelper(const DeleteMeshRequest & request,const DeleteMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const437 void AppMeshClient::DeleteMeshAsyncHelper(const DeleteMeshRequest& request, const DeleteMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
438 {
439 handler(this, request, DeleteMesh(request), context);
440 }
441
DeleteRoute(const DeleteRouteRequest & request) const442 DeleteRouteOutcome AppMeshClient::DeleteRoute(const DeleteRouteRequest& request) const
443 {
444 if (!request.MeshNameHasBeenSet())
445 {
446 AWS_LOGSTREAM_ERROR("DeleteRoute", "Required field: MeshName, is not set");
447 return DeleteRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
448 }
449 if (!request.RouteNameHasBeenSet())
450 {
451 AWS_LOGSTREAM_ERROR("DeleteRoute", "Required field: RouteName, is not set");
452 return DeleteRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RouteName]", false));
453 }
454 if (!request.VirtualRouterNameHasBeenSet())
455 {
456 AWS_LOGSTREAM_ERROR("DeleteRoute", "Required field: VirtualRouterName, is not set");
457 return DeleteRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
458 }
459 Aws::Http::URI uri = m_uri;
460 uri.AddPathSegments("/v20190125/meshes/");
461 uri.AddPathSegment(request.GetMeshName());
462 uri.AddPathSegments("/virtualRouter/");
463 uri.AddPathSegment(request.GetVirtualRouterName());
464 uri.AddPathSegments("/routes/");
465 uri.AddPathSegment(request.GetRouteName());
466 return DeleteRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
467 }
468
DeleteRouteCallable(const DeleteRouteRequest & request) const469 DeleteRouteOutcomeCallable AppMeshClient::DeleteRouteCallable(const DeleteRouteRequest& request) const
470 {
471 auto task = Aws::MakeShared< std::packaged_task< DeleteRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRoute(request); } );
472 auto packagedFunction = [task]() { (*task)(); };
473 m_executor->Submit(packagedFunction);
474 return task->get_future();
475 }
476
DeleteRouteAsync(const DeleteRouteRequest & request,const DeleteRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const477 void AppMeshClient::DeleteRouteAsync(const DeleteRouteRequest& request, const DeleteRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
478 {
479 m_executor->Submit( [this, request, handler, context](){ this->DeleteRouteAsyncHelper( request, handler, context ); } );
480 }
481
DeleteRouteAsyncHelper(const DeleteRouteRequest & request,const DeleteRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const482 void AppMeshClient::DeleteRouteAsyncHelper(const DeleteRouteRequest& request, const DeleteRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
483 {
484 handler(this, request, DeleteRoute(request), context);
485 }
486
DeleteVirtualGateway(const DeleteVirtualGatewayRequest & request) const487 DeleteVirtualGatewayOutcome AppMeshClient::DeleteVirtualGateway(const DeleteVirtualGatewayRequest& request) const
488 {
489 if (!request.MeshNameHasBeenSet())
490 {
491 AWS_LOGSTREAM_ERROR("DeleteVirtualGateway", "Required field: MeshName, is not set");
492 return DeleteVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
493 }
494 if (!request.VirtualGatewayNameHasBeenSet())
495 {
496 AWS_LOGSTREAM_ERROR("DeleteVirtualGateway", "Required field: VirtualGatewayName, is not set");
497 return DeleteVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
498 }
499 Aws::Http::URI uri = m_uri;
500 uri.AddPathSegments("/v20190125/meshes/");
501 uri.AddPathSegment(request.GetMeshName());
502 uri.AddPathSegments("/virtualGateways/");
503 uri.AddPathSegment(request.GetVirtualGatewayName());
504 return DeleteVirtualGatewayOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
505 }
506
DeleteVirtualGatewayCallable(const DeleteVirtualGatewayRequest & request) const507 DeleteVirtualGatewayOutcomeCallable AppMeshClient::DeleteVirtualGatewayCallable(const DeleteVirtualGatewayRequest& request) const
508 {
509 auto task = Aws::MakeShared< std::packaged_task< DeleteVirtualGatewayOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVirtualGateway(request); } );
510 auto packagedFunction = [task]() { (*task)(); };
511 m_executor->Submit(packagedFunction);
512 return task->get_future();
513 }
514
DeleteVirtualGatewayAsync(const DeleteVirtualGatewayRequest & request,const DeleteVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const515 void AppMeshClient::DeleteVirtualGatewayAsync(const DeleteVirtualGatewayRequest& request, const DeleteVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
516 {
517 m_executor->Submit( [this, request, handler, context](){ this->DeleteVirtualGatewayAsyncHelper( request, handler, context ); } );
518 }
519
DeleteVirtualGatewayAsyncHelper(const DeleteVirtualGatewayRequest & request,const DeleteVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const520 void AppMeshClient::DeleteVirtualGatewayAsyncHelper(const DeleteVirtualGatewayRequest& request, const DeleteVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
521 {
522 handler(this, request, DeleteVirtualGateway(request), context);
523 }
524
DeleteVirtualNode(const DeleteVirtualNodeRequest & request) const525 DeleteVirtualNodeOutcome AppMeshClient::DeleteVirtualNode(const DeleteVirtualNodeRequest& request) const
526 {
527 if (!request.MeshNameHasBeenSet())
528 {
529 AWS_LOGSTREAM_ERROR("DeleteVirtualNode", "Required field: MeshName, is not set");
530 return DeleteVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
531 }
532 if (!request.VirtualNodeNameHasBeenSet())
533 {
534 AWS_LOGSTREAM_ERROR("DeleteVirtualNode", "Required field: VirtualNodeName, is not set");
535 return DeleteVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualNodeName]", false));
536 }
537 Aws::Http::URI uri = m_uri;
538 uri.AddPathSegments("/v20190125/meshes/");
539 uri.AddPathSegment(request.GetMeshName());
540 uri.AddPathSegments("/virtualNodes/");
541 uri.AddPathSegment(request.GetVirtualNodeName());
542 return DeleteVirtualNodeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
543 }
544
DeleteVirtualNodeCallable(const DeleteVirtualNodeRequest & request) const545 DeleteVirtualNodeOutcomeCallable AppMeshClient::DeleteVirtualNodeCallable(const DeleteVirtualNodeRequest& request) const
546 {
547 auto task = Aws::MakeShared< std::packaged_task< DeleteVirtualNodeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVirtualNode(request); } );
548 auto packagedFunction = [task]() { (*task)(); };
549 m_executor->Submit(packagedFunction);
550 return task->get_future();
551 }
552
DeleteVirtualNodeAsync(const DeleteVirtualNodeRequest & request,const DeleteVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const553 void AppMeshClient::DeleteVirtualNodeAsync(const DeleteVirtualNodeRequest& request, const DeleteVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
554 {
555 m_executor->Submit( [this, request, handler, context](){ this->DeleteVirtualNodeAsyncHelper( request, handler, context ); } );
556 }
557
DeleteVirtualNodeAsyncHelper(const DeleteVirtualNodeRequest & request,const DeleteVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const558 void AppMeshClient::DeleteVirtualNodeAsyncHelper(const DeleteVirtualNodeRequest& request, const DeleteVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
559 {
560 handler(this, request, DeleteVirtualNode(request), context);
561 }
562
DeleteVirtualRouter(const DeleteVirtualRouterRequest & request) const563 DeleteVirtualRouterOutcome AppMeshClient::DeleteVirtualRouter(const DeleteVirtualRouterRequest& request) const
564 {
565 if (!request.MeshNameHasBeenSet())
566 {
567 AWS_LOGSTREAM_ERROR("DeleteVirtualRouter", "Required field: MeshName, is not set");
568 return DeleteVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
569 }
570 if (!request.VirtualRouterNameHasBeenSet())
571 {
572 AWS_LOGSTREAM_ERROR("DeleteVirtualRouter", "Required field: VirtualRouterName, is not set");
573 return DeleteVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
574 }
575 Aws::Http::URI uri = m_uri;
576 uri.AddPathSegments("/v20190125/meshes/");
577 uri.AddPathSegment(request.GetMeshName());
578 uri.AddPathSegments("/virtualRouters/");
579 uri.AddPathSegment(request.GetVirtualRouterName());
580 return DeleteVirtualRouterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
581 }
582
DeleteVirtualRouterCallable(const DeleteVirtualRouterRequest & request) const583 DeleteVirtualRouterOutcomeCallable AppMeshClient::DeleteVirtualRouterCallable(const DeleteVirtualRouterRequest& request) const
584 {
585 auto task = Aws::MakeShared< std::packaged_task< DeleteVirtualRouterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVirtualRouter(request); } );
586 auto packagedFunction = [task]() { (*task)(); };
587 m_executor->Submit(packagedFunction);
588 return task->get_future();
589 }
590
DeleteVirtualRouterAsync(const DeleteVirtualRouterRequest & request,const DeleteVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const591 void AppMeshClient::DeleteVirtualRouterAsync(const DeleteVirtualRouterRequest& request, const DeleteVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
592 {
593 m_executor->Submit( [this, request, handler, context](){ this->DeleteVirtualRouterAsyncHelper( request, handler, context ); } );
594 }
595
DeleteVirtualRouterAsyncHelper(const DeleteVirtualRouterRequest & request,const DeleteVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const596 void AppMeshClient::DeleteVirtualRouterAsyncHelper(const DeleteVirtualRouterRequest& request, const DeleteVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
597 {
598 handler(this, request, DeleteVirtualRouter(request), context);
599 }
600
DeleteVirtualService(const DeleteVirtualServiceRequest & request) const601 DeleteVirtualServiceOutcome AppMeshClient::DeleteVirtualService(const DeleteVirtualServiceRequest& request) const
602 {
603 if (!request.MeshNameHasBeenSet())
604 {
605 AWS_LOGSTREAM_ERROR("DeleteVirtualService", "Required field: MeshName, is not set");
606 return DeleteVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
607 }
608 if (!request.VirtualServiceNameHasBeenSet())
609 {
610 AWS_LOGSTREAM_ERROR("DeleteVirtualService", "Required field: VirtualServiceName, is not set");
611 return DeleteVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualServiceName]", false));
612 }
613 Aws::Http::URI uri = m_uri;
614 uri.AddPathSegments("/v20190125/meshes/");
615 uri.AddPathSegment(request.GetMeshName());
616 uri.AddPathSegments("/virtualServices/");
617 uri.AddPathSegment(request.GetVirtualServiceName());
618 return DeleteVirtualServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
619 }
620
DeleteVirtualServiceCallable(const DeleteVirtualServiceRequest & request) const621 DeleteVirtualServiceOutcomeCallable AppMeshClient::DeleteVirtualServiceCallable(const DeleteVirtualServiceRequest& request) const
622 {
623 auto task = Aws::MakeShared< std::packaged_task< DeleteVirtualServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVirtualService(request); } );
624 auto packagedFunction = [task]() { (*task)(); };
625 m_executor->Submit(packagedFunction);
626 return task->get_future();
627 }
628
DeleteVirtualServiceAsync(const DeleteVirtualServiceRequest & request,const DeleteVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const629 void AppMeshClient::DeleteVirtualServiceAsync(const DeleteVirtualServiceRequest& request, const DeleteVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
630 {
631 m_executor->Submit( [this, request, handler, context](){ this->DeleteVirtualServiceAsyncHelper( request, handler, context ); } );
632 }
633
DeleteVirtualServiceAsyncHelper(const DeleteVirtualServiceRequest & request,const DeleteVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const634 void AppMeshClient::DeleteVirtualServiceAsyncHelper(const DeleteVirtualServiceRequest& request, const DeleteVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
635 {
636 handler(this, request, DeleteVirtualService(request), context);
637 }
638
DescribeGatewayRoute(const DescribeGatewayRouteRequest & request) const639 DescribeGatewayRouteOutcome AppMeshClient::DescribeGatewayRoute(const DescribeGatewayRouteRequest& request) const
640 {
641 if (!request.GatewayRouteNameHasBeenSet())
642 {
643 AWS_LOGSTREAM_ERROR("DescribeGatewayRoute", "Required field: GatewayRouteName, is not set");
644 return DescribeGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [GatewayRouteName]", false));
645 }
646 if (!request.MeshNameHasBeenSet())
647 {
648 AWS_LOGSTREAM_ERROR("DescribeGatewayRoute", "Required field: MeshName, is not set");
649 return DescribeGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
650 }
651 if (!request.VirtualGatewayNameHasBeenSet())
652 {
653 AWS_LOGSTREAM_ERROR("DescribeGatewayRoute", "Required field: VirtualGatewayName, is not set");
654 return DescribeGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
655 }
656 Aws::Http::URI uri = m_uri;
657 uri.AddPathSegments("/v20190125/meshes/");
658 uri.AddPathSegment(request.GetMeshName());
659 uri.AddPathSegments("/virtualGateway/");
660 uri.AddPathSegment(request.GetVirtualGatewayName());
661 uri.AddPathSegments("/gatewayRoutes/");
662 uri.AddPathSegment(request.GetGatewayRouteName());
663 return DescribeGatewayRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
664 }
665
DescribeGatewayRouteCallable(const DescribeGatewayRouteRequest & request) const666 DescribeGatewayRouteOutcomeCallable AppMeshClient::DescribeGatewayRouteCallable(const DescribeGatewayRouteRequest& request) const
667 {
668 auto task = Aws::MakeShared< std::packaged_task< DescribeGatewayRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeGatewayRoute(request); } );
669 auto packagedFunction = [task]() { (*task)(); };
670 m_executor->Submit(packagedFunction);
671 return task->get_future();
672 }
673
DescribeGatewayRouteAsync(const DescribeGatewayRouteRequest & request,const DescribeGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const674 void AppMeshClient::DescribeGatewayRouteAsync(const DescribeGatewayRouteRequest& request, const DescribeGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
675 {
676 m_executor->Submit( [this, request, handler, context](){ this->DescribeGatewayRouteAsyncHelper( request, handler, context ); } );
677 }
678
DescribeGatewayRouteAsyncHelper(const DescribeGatewayRouteRequest & request,const DescribeGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const679 void AppMeshClient::DescribeGatewayRouteAsyncHelper(const DescribeGatewayRouteRequest& request, const DescribeGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
680 {
681 handler(this, request, DescribeGatewayRoute(request), context);
682 }
683
DescribeMesh(const DescribeMeshRequest & request) const684 DescribeMeshOutcome AppMeshClient::DescribeMesh(const DescribeMeshRequest& request) const
685 {
686 if (!request.MeshNameHasBeenSet())
687 {
688 AWS_LOGSTREAM_ERROR("DescribeMesh", "Required field: MeshName, is not set");
689 return DescribeMeshOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
690 }
691 Aws::Http::URI uri = m_uri;
692 uri.AddPathSegments("/v20190125/meshes/");
693 uri.AddPathSegment(request.GetMeshName());
694 return DescribeMeshOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
695 }
696
DescribeMeshCallable(const DescribeMeshRequest & request) const697 DescribeMeshOutcomeCallable AppMeshClient::DescribeMeshCallable(const DescribeMeshRequest& request) const
698 {
699 auto task = Aws::MakeShared< std::packaged_task< DescribeMeshOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeMesh(request); } );
700 auto packagedFunction = [task]() { (*task)(); };
701 m_executor->Submit(packagedFunction);
702 return task->get_future();
703 }
704
DescribeMeshAsync(const DescribeMeshRequest & request,const DescribeMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const705 void AppMeshClient::DescribeMeshAsync(const DescribeMeshRequest& request, const DescribeMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
706 {
707 m_executor->Submit( [this, request, handler, context](){ this->DescribeMeshAsyncHelper( request, handler, context ); } );
708 }
709
DescribeMeshAsyncHelper(const DescribeMeshRequest & request,const DescribeMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const710 void AppMeshClient::DescribeMeshAsyncHelper(const DescribeMeshRequest& request, const DescribeMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
711 {
712 handler(this, request, DescribeMesh(request), context);
713 }
714
DescribeRoute(const DescribeRouteRequest & request) const715 DescribeRouteOutcome AppMeshClient::DescribeRoute(const DescribeRouteRequest& request) const
716 {
717 if (!request.MeshNameHasBeenSet())
718 {
719 AWS_LOGSTREAM_ERROR("DescribeRoute", "Required field: MeshName, is not set");
720 return DescribeRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
721 }
722 if (!request.RouteNameHasBeenSet())
723 {
724 AWS_LOGSTREAM_ERROR("DescribeRoute", "Required field: RouteName, is not set");
725 return DescribeRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RouteName]", false));
726 }
727 if (!request.VirtualRouterNameHasBeenSet())
728 {
729 AWS_LOGSTREAM_ERROR("DescribeRoute", "Required field: VirtualRouterName, is not set");
730 return DescribeRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
731 }
732 Aws::Http::URI uri = m_uri;
733 uri.AddPathSegments("/v20190125/meshes/");
734 uri.AddPathSegment(request.GetMeshName());
735 uri.AddPathSegments("/virtualRouter/");
736 uri.AddPathSegment(request.GetVirtualRouterName());
737 uri.AddPathSegments("/routes/");
738 uri.AddPathSegment(request.GetRouteName());
739 return DescribeRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
740 }
741
DescribeRouteCallable(const DescribeRouteRequest & request) const742 DescribeRouteOutcomeCallable AppMeshClient::DescribeRouteCallable(const DescribeRouteRequest& request) const
743 {
744 auto task = Aws::MakeShared< std::packaged_task< DescribeRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeRoute(request); } );
745 auto packagedFunction = [task]() { (*task)(); };
746 m_executor->Submit(packagedFunction);
747 return task->get_future();
748 }
749
DescribeRouteAsync(const DescribeRouteRequest & request,const DescribeRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const750 void AppMeshClient::DescribeRouteAsync(const DescribeRouteRequest& request, const DescribeRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
751 {
752 m_executor->Submit( [this, request, handler, context](){ this->DescribeRouteAsyncHelper( request, handler, context ); } );
753 }
754
DescribeRouteAsyncHelper(const DescribeRouteRequest & request,const DescribeRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const755 void AppMeshClient::DescribeRouteAsyncHelper(const DescribeRouteRequest& request, const DescribeRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
756 {
757 handler(this, request, DescribeRoute(request), context);
758 }
759
DescribeVirtualGateway(const DescribeVirtualGatewayRequest & request) const760 DescribeVirtualGatewayOutcome AppMeshClient::DescribeVirtualGateway(const DescribeVirtualGatewayRequest& request) const
761 {
762 if (!request.MeshNameHasBeenSet())
763 {
764 AWS_LOGSTREAM_ERROR("DescribeVirtualGateway", "Required field: MeshName, is not set");
765 return DescribeVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
766 }
767 if (!request.VirtualGatewayNameHasBeenSet())
768 {
769 AWS_LOGSTREAM_ERROR("DescribeVirtualGateway", "Required field: VirtualGatewayName, is not set");
770 return DescribeVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
771 }
772 Aws::Http::URI uri = m_uri;
773 uri.AddPathSegments("/v20190125/meshes/");
774 uri.AddPathSegment(request.GetMeshName());
775 uri.AddPathSegments("/virtualGateways/");
776 uri.AddPathSegment(request.GetVirtualGatewayName());
777 return DescribeVirtualGatewayOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
778 }
779
DescribeVirtualGatewayCallable(const DescribeVirtualGatewayRequest & request) const780 DescribeVirtualGatewayOutcomeCallable AppMeshClient::DescribeVirtualGatewayCallable(const DescribeVirtualGatewayRequest& request) const
781 {
782 auto task = Aws::MakeShared< std::packaged_task< DescribeVirtualGatewayOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeVirtualGateway(request); } );
783 auto packagedFunction = [task]() { (*task)(); };
784 m_executor->Submit(packagedFunction);
785 return task->get_future();
786 }
787
DescribeVirtualGatewayAsync(const DescribeVirtualGatewayRequest & request,const DescribeVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const788 void AppMeshClient::DescribeVirtualGatewayAsync(const DescribeVirtualGatewayRequest& request, const DescribeVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
789 {
790 m_executor->Submit( [this, request, handler, context](){ this->DescribeVirtualGatewayAsyncHelper( request, handler, context ); } );
791 }
792
DescribeVirtualGatewayAsyncHelper(const DescribeVirtualGatewayRequest & request,const DescribeVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const793 void AppMeshClient::DescribeVirtualGatewayAsyncHelper(const DescribeVirtualGatewayRequest& request, const DescribeVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
794 {
795 handler(this, request, DescribeVirtualGateway(request), context);
796 }
797
DescribeVirtualNode(const DescribeVirtualNodeRequest & request) const798 DescribeVirtualNodeOutcome AppMeshClient::DescribeVirtualNode(const DescribeVirtualNodeRequest& request) const
799 {
800 if (!request.MeshNameHasBeenSet())
801 {
802 AWS_LOGSTREAM_ERROR("DescribeVirtualNode", "Required field: MeshName, is not set");
803 return DescribeVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
804 }
805 if (!request.VirtualNodeNameHasBeenSet())
806 {
807 AWS_LOGSTREAM_ERROR("DescribeVirtualNode", "Required field: VirtualNodeName, is not set");
808 return DescribeVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualNodeName]", false));
809 }
810 Aws::Http::URI uri = m_uri;
811 uri.AddPathSegments("/v20190125/meshes/");
812 uri.AddPathSegment(request.GetMeshName());
813 uri.AddPathSegments("/virtualNodes/");
814 uri.AddPathSegment(request.GetVirtualNodeName());
815 return DescribeVirtualNodeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
816 }
817
DescribeVirtualNodeCallable(const DescribeVirtualNodeRequest & request) const818 DescribeVirtualNodeOutcomeCallable AppMeshClient::DescribeVirtualNodeCallable(const DescribeVirtualNodeRequest& request) const
819 {
820 auto task = Aws::MakeShared< std::packaged_task< DescribeVirtualNodeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeVirtualNode(request); } );
821 auto packagedFunction = [task]() { (*task)(); };
822 m_executor->Submit(packagedFunction);
823 return task->get_future();
824 }
825
DescribeVirtualNodeAsync(const DescribeVirtualNodeRequest & request,const DescribeVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const826 void AppMeshClient::DescribeVirtualNodeAsync(const DescribeVirtualNodeRequest& request, const DescribeVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
827 {
828 m_executor->Submit( [this, request, handler, context](){ this->DescribeVirtualNodeAsyncHelper( request, handler, context ); } );
829 }
830
DescribeVirtualNodeAsyncHelper(const DescribeVirtualNodeRequest & request,const DescribeVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const831 void AppMeshClient::DescribeVirtualNodeAsyncHelper(const DescribeVirtualNodeRequest& request, const DescribeVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
832 {
833 handler(this, request, DescribeVirtualNode(request), context);
834 }
835
DescribeVirtualRouter(const DescribeVirtualRouterRequest & request) const836 DescribeVirtualRouterOutcome AppMeshClient::DescribeVirtualRouter(const DescribeVirtualRouterRequest& request) const
837 {
838 if (!request.MeshNameHasBeenSet())
839 {
840 AWS_LOGSTREAM_ERROR("DescribeVirtualRouter", "Required field: MeshName, is not set");
841 return DescribeVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
842 }
843 if (!request.VirtualRouterNameHasBeenSet())
844 {
845 AWS_LOGSTREAM_ERROR("DescribeVirtualRouter", "Required field: VirtualRouterName, is not set");
846 return DescribeVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
847 }
848 Aws::Http::URI uri = m_uri;
849 uri.AddPathSegments("/v20190125/meshes/");
850 uri.AddPathSegment(request.GetMeshName());
851 uri.AddPathSegments("/virtualRouters/");
852 uri.AddPathSegment(request.GetVirtualRouterName());
853 return DescribeVirtualRouterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
854 }
855
DescribeVirtualRouterCallable(const DescribeVirtualRouterRequest & request) const856 DescribeVirtualRouterOutcomeCallable AppMeshClient::DescribeVirtualRouterCallable(const DescribeVirtualRouterRequest& request) const
857 {
858 auto task = Aws::MakeShared< std::packaged_task< DescribeVirtualRouterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeVirtualRouter(request); } );
859 auto packagedFunction = [task]() { (*task)(); };
860 m_executor->Submit(packagedFunction);
861 return task->get_future();
862 }
863
DescribeVirtualRouterAsync(const DescribeVirtualRouterRequest & request,const DescribeVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const864 void AppMeshClient::DescribeVirtualRouterAsync(const DescribeVirtualRouterRequest& request, const DescribeVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
865 {
866 m_executor->Submit( [this, request, handler, context](){ this->DescribeVirtualRouterAsyncHelper( request, handler, context ); } );
867 }
868
DescribeVirtualRouterAsyncHelper(const DescribeVirtualRouterRequest & request,const DescribeVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const869 void AppMeshClient::DescribeVirtualRouterAsyncHelper(const DescribeVirtualRouterRequest& request, const DescribeVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
870 {
871 handler(this, request, DescribeVirtualRouter(request), context);
872 }
873
DescribeVirtualService(const DescribeVirtualServiceRequest & request) const874 DescribeVirtualServiceOutcome AppMeshClient::DescribeVirtualService(const DescribeVirtualServiceRequest& request) const
875 {
876 if (!request.MeshNameHasBeenSet())
877 {
878 AWS_LOGSTREAM_ERROR("DescribeVirtualService", "Required field: MeshName, is not set");
879 return DescribeVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
880 }
881 if (!request.VirtualServiceNameHasBeenSet())
882 {
883 AWS_LOGSTREAM_ERROR("DescribeVirtualService", "Required field: VirtualServiceName, is not set");
884 return DescribeVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualServiceName]", false));
885 }
886 Aws::Http::URI uri = m_uri;
887 uri.AddPathSegments("/v20190125/meshes/");
888 uri.AddPathSegment(request.GetMeshName());
889 uri.AddPathSegments("/virtualServices/");
890 uri.AddPathSegment(request.GetVirtualServiceName());
891 return DescribeVirtualServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
892 }
893
DescribeVirtualServiceCallable(const DescribeVirtualServiceRequest & request) const894 DescribeVirtualServiceOutcomeCallable AppMeshClient::DescribeVirtualServiceCallable(const DescribeVirtualServiceRequest& request) const
895 {
896 auto task = Aws::MakeShared< std::packaged_task< DescribeVirtualServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeVirtualService(request); } );
897 auto packagedFunction = [task]() { (*task)(); };
898 m_executor->Submit(packagedFunction);
899 return task->get_future();
900 }
901
DescribeVirtualServiceAsync(const DescribeVirtualServiceRequest & request,const DescribeVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const902 void AppMeshClient::DescribeVirtualServiceAsync(const DescribeVirtualServiceRequest& request, const DescribeVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
903 {
904 m_executor->Submit( [this, request, handler, context](){ this->DescribeVirtualServiceAsyncHelper( request, handler, context ); } );
905 }
906
DescribeVirtualServiceAsyncHelper(const DescribeVirtualServiceRequest & request,const DescribeVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const907 void AppMeshClient::DescribeVirtualServiceAsyncHelper(const DescribeVirtualServiceRequest& request, const DescribeVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
908 {
909 handler(this, request, DescribeVirtualService(request), context);
910 }
911
ListGatewayRoutes(const ListGatewayRoutesRequest & request) const912 ListGatewayRoutesOutcome AppMeshClient::ListGatewayRoutes(const ListGatewayRoutesRequest& request) const
913 {
914 if (!request.MeshNameHasBeenSet())
915 {
916 AWS_LOGSTREAM_ERROR("ListGatewayRoutes", "Required field: MeshName, is not set");
917 return ListGatewayRoutesOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
918 }
919 if (!request.VirtualGatewayNameHasBeenSet())
920 {
921 AWS_LOGSTREAM_ERROR("ListGatewayRoutes", "Required field: VirtualGatewayName, is not set");
922 return ListGatewayRoutesOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
923 }
924 Aws::Http::URI uri = m_uri;
925 uri.AddPathSegments("/v20190125/meshes/");
926 uri.AddPathSegment(request.GetMeshName());
927 uri.AddPathSegments("/virtualGateway/");
928 uri.AddPathSegment(request.GetVirtualGatewayName());
929 uri.AddPathSegments("/gatewayRoutes");
930 return ListGatewayRoutesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
931 }
932
ListGatewayRoutesCallable(const ListGatewayRoutesRequest & request) const933 ListGatewayRoutesOutcomeCallable AppMeshClient::ListGatewayRoutesCallable(const ListGatewayRoutesRequest& request) const
934 {
935 auto task = Aws::MakeShared< std::packaged_task< ListGatewayRoutesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGatewayRoutes(request); } );
936 auto packagedFunction = [task]() { (*task)(); };
937 m_executor->Submit(packagedFunction);
938 return task->get_future();
939 }
940
ListGatewayRoutesAsync(const ListGatewayRoutesRequest & request,const ListGatewayRoutesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const941 void AppMeshClient::ListGatewayRoutesAsync(const ListGatewayRoutesRequest& request, const ListGatewayRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
942 {
943 m_executor->Submit( [this, request, handler, context](){ this->ListGatewayRoutesAsyncHelper( request, handler, context ); } );
944 }
945
ListGatewayRoutesAsyncHelper(const ListGatewayRoutesRequest & request,const ListGatewayRoutesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const946 void AppMeshClient::ListGatewayRoutesAsyncHelper(const ListGatewayRoutesRequest& request, const ListGatewayRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
947 {
948 handler(this, request, ListGatewayRoutes(request), context);
949 }
950
ListMeshes(const ListMeshesRequest & request) const951 ListMeshesOutcome AppMeshClient::ListMeshes(const ListMeshesRequest& request) const
952 {
953 Aws::Http::URI uri = m_uri;
954 uri.AddPathSegments("/v20190125/meshes");
955 return ListMeshesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
956 }
957
ListMeshesCallable(const ListMeshesRequest & request) const958 ListMeshesOutcomeCallable AppMeshClient::ListMeshesCallable(const ListMeshesRequest& request) const
959 {
960 auto task = Aws::MakeShared< std::packaged_task< ListMeshesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMeshes(request); } );
961 auto packagedFunction = [task]() { (*task)(); };
962 m_executor->Submit(packagedFunction);
963 return task->get_future();
964 }
965
ListMeshesAsync(const ListMeshesRequest & request,const ListMeshesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const966 void AppMeshClient::ListMeshesAsync(const ListMeshesRequest& request, const ListMeshesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
967 {
968 m_executor->Submit( [this, request, handler, context](){ this->ListMeshesAsyncHelper( request, handler, context ); } );
969 }
970
ListMeshesAsyncHelper(const ListMeshesRequest & request,const ListMeshesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const971 void AppMeshClient::ListMeshesAsyncHelper(const ListMeshesRequest& request, const ListMeshesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
972 {
973 handler(this, request, ListMeshes(request), context);
974 }
975
ListRoutes(const ListRoutesRequest & request) const976 ListRoutesOutcome AppMeshClient::ListRoutes(const ListRoutesRequest& request) const
977 {
978 if (!request.MeshNameHasBeenSet())
979 {
980 AWS_LOGSTREAM_ERROR("ListRoutes", "Required field: MeshName, is not set");
981 return ListRoutesOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
982 }
983 if (!request.VirtualRouterNameHasBeenSet())
984 {
985 AWS_LOGSTREAM_ERROR("ListRoutes", "Required field: VirtualRouterName, is not set");
986 return ListRoutesOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
987 }
988 Aws::Http::URI uri = m_uri;
989 uri.AddPathSegments("/v20190125/meshes/");
990 uri.AddPathSegment(request.GetMeshName());
991 uri.AddPathSegments("/virtualRouter/");
992 uri.AddPathSegment(request.GetVirtualRouterName());
993 uri.AddPathSegments("/routes");
994 return ListRoutesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
995 }
996
ListRoutesCallable(const ListRoutesRequest & request) const997 ListRoutesOutcomeCallable AppMeshClient::ListRoutesCallable(const ListRoutesRequest& request) const
998 {
999 auto task = Aws::MakeShared< std::packaged_task< ListRoutesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRoutes(request); } );
1000 auto packagedFunction = [task]() { (*task)(); };
1001 m_executor->Submit(packagedFunction);
1002 return task->get_future();
1003 }
1004
ListRoutesAsync(const ListRoutesRequest & request,const ListRoutesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1005 void AppMeshClient::ListRoutesAsync(const ListRoutesRequest& request, const ListRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1006 {
1007 m_executor->Submit( [this, request, handler, context](){ this->ListRoutesAsyncHelper( request, handler, context ); } );
1008 }
1009
ListRoutesAsyncHelper(const ListRoutesRequest & request,const ListRoutesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1010 void AppMeshClient::ListRoutesAsyncHelper(const ListRoutesRequest& request, const ListRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1011 {
1012 handler(this, request, ListRoutes(request), context);
1013 }
1014
ListTagsForResource(const ListTagsForResourceRequest & request) const1015 ListTagsForResourceOutcome AppMeshClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
1016 {
1017 if (!request.ResourceArnHasBeenSet())
1018 {
1019 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
1020 return ListTagsForResourceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1021 }
1022 Aws::Http::URI uri = m_uri;
1023 uri.AddPathSegments("/v20190125/tags");
1024 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1025 }
1026
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const1027 ListTagsForResourceOutcomeCallable AppMeshClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
1028 {
1029 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
1030 auto packagedFunction = [task]() { (*task)(); };
1031 m_executor->Submit(packagedFunction);
1032 return task->get_future();
1033 }
1034
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1035 void AppMeshClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1036 {
1037 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
1038 }
1039
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1040 void AppMeshClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1041 {
1042 handler(this, request, ListTagsForResource(request), context);
1043 }
1044
ListVirtualGateways(const ListVirtualGatewaysRequest & request) const1045 ListVirtualGatewaysOutcome AppMeshClient::ListVirtualGateways(const ListVirtualGatewaysRequest& request) const
1046 {
1047 if (!request.MeshNameHasBeenSet())
1048 {
1049 AWS_LOGSTREAM_ERROR("ListVirtualGateways", "Required field: MeshName, is not set");
1050 return ListVirtualGatewaysOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1051 }
1052 Aws::Http::URI uri = m_uri;
1053 uri.AddPathSegments("/v20190125/meshes/");
1054 uri.AddPathSegment(request.GetMeshName());
1055 uri.AddPathSegments("/virtualGateways");
1056 return ListVirtualGatewaysOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1057 }
1058
ListVirtualGatewaysCallable(const ListVirtualGatewaysRequest & request) const1059 ListVirtualGatewaysOutcomeCallable AppMeshClient::ListVirtualGatewaysCallable(const ListVirtualGatewaysRequest& request) const
1060 {
1061 auto task = Aws::MakeShared< std::packaged_task< ListVirtualGatewaysOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVirtualGateways(request); } );
1062 auto packagedFunction = [task]() { (*task)(); };
1063 m_executor->Submit(packagedFunction);
1064 return task->get_future();
1065 }
1066
ListVirtualGatewaysAsync(const ListVirtualGatewaysRequest & request,const ListVirtualGatewaysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1067 void AppMeshClient::ListVirtualGatewaysAsync(const ListVirtualGatewaysRequest& request, const ListVirtualGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1068 {
1069 m_executor->Submit( [this, request, handler, context](){ this->ListVirtualGatewaysAsyncHelper( request, handler, context ); } );
1070 }
1071
ListVirtualGatewaysAsyncHelper(const ListVirtualGatewaysRequest & request,const ListVirtualGatewaysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1072 void AppMeshClient::ListVirtualGatewaysAsyncHelper(const ListVirtualGatewaysRequest& request, const ListVirtualGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1073 {
1074 handler(this, request, ListVirtualGateways(request), context);
1075 }
1076
ListVirtualNodes(const ListVirtualNodesRequest & request) const1077 ListVirtualNodesOutcome AppMeshClient::ListVirtualNodes(const ListVirtualNodesRequest& request) const
1078 {
1079 if (!request.MeshNameHasBeenSet())
1080 {
1081 AWS_LOGSTREAM_ERROR("ListVirtualNodes", "Required field: MeshName, is not set");
1082 return ListVirtualNodesOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1083 }
1084 Aws::Http::URI uri = m_uri;
1085 uri.AddPathSegments("/v20190125/meshes/");
1086 uri.AddPathSegment(request.GetMeshName());
1087 uri.AddPathSegments("/virtualNodes");
1088 return ListVirtualNodesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1089 }
1090
ListVirtualNodesCallable(const ListVirtualNodesRequest & request) const1091 ListVirtualNodesOutcomeCallable AppMeshClient::ListVirtualNodesCallable(const ListVirtualNodesRequest& request) const
1092 {
1093 auto task = Aws::MakeShared< std::packaged_task< ListVirtualNodesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVirtualNodes(request); } );
1094 auto packagedFunction = [task]() { (*task)(); };
1095 m_executor->Submit(packagedFunction);
1096 return task->get_future();
1097 }
1098
ListVirtualNodesAsync(const ListVirtualNodesRequest & request,const ListVirtualNodesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1099 void AppMeshClient::ListVirtualNodesAsync(const ListVirtualNodesRequest& request, const ListVirtualNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1100 {
1101 m_executor->Submit( [this, request, handler, context](){ this->ListVirtualNodesAsyncHelper( request, handler, context ); } );
1102 }
1103
ListVirtualNodesAsyncHelper(const ListVirtualNodesRequest & request,const ListVirtualNodesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1104 void AppMeshClient::ListVirtualNodesAsyncHelper(const ListVirtualNodesRequest& request, const ListVirtualNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1105 {
1106 handler(this, request, ListVirtualNodes(request), context);
1107 }
1108
ListVirtualRouters(const ListVirtualRoutersRequest & request) const1109 ListVirtualRoutersOutcome AppMeshClient::ListVirtualRouters(const ListVirtualRoutersRequest& request) const
1110 {
1111 if (!request.MeshNameHasBeenSet())
1112 {
1113 AWS_LOGSTREAM_ERROR("ListVirtualRouters", "Required field: MeshName, is not set");
1114 return ListVirtualRoutersOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1115 }
1116 Aws::Http::URI uri = m_uri;
1117 uri.AddPathSegments("/v20190125/meshes/");
1118 uri.AddPathSegment(request.GetMeshName());
1119 uri.AddPathSegments("/virtualRouters");
1120 return ListVirtualRoutersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1121 }
1122
ListVirtualRoutersCallable(const ListVirtualRoutersRequest & request) const1123 ListVirtualRoutersOutcomeCallable AppMeshClient::ListVirtualRoutersCallable(const ListVirtualRoutersRequest& request) const
1124 {
1125 auto task = Aws::MakeShared< std::packaged_task< ListVirtualRoutersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVirtualRouters(request); } );
1126 auto packagedFunction = [task]() { (*task)(); };
1127 m_executor->Submit(packagedFunction);
1128 return task->get_future();
1129 }
1130
ListVirtualRoutersAsync(const ListVirtualRoutersRequest & request,const ListVirtualRoutersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1131 void AppMeshClient::ListVirtualRoutersAsync(const ListVirtualRoutersRequest& request, const ListVirtualRoutersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1132 {
1133 m_executor->Submit( [this, request, handler, context](){ this->ListVirtualRoutersAsyncHelper( request, handler, context ); } );
1134 }
1135
ListVirtualRoutersAsyncHelper(const ListVirtualRoutersRequest & request,const ListVirtualRoutersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1136 void AppMeshClient::ListVirtualRoutersAsyncHelper(const ListVirtualRoutersRequest& request, const ListVirtualRoutersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1137 {
1138 handler(this, request, ListVirtualRouters(request), context);
1139 }
1140
ListVirtualServices(const ListVirtualServicesRequest & request) const1141 ListVirtualServicesOutcome AppMeshClient::ListVirtualServices(const ListVirtualServicesRequest& request) const
1142 {
1143 if (!request.MeshNameHasBeenSet())
1144 {
1145 AWS_LOGSTREAM_ERROR("ListVirtualServices", "Required field: MeshName, is not set");
1146 return ListVirtualServicesOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1147 }
1148 Aws::Http::URI uri = m_uri;
1149 uri.AddPathSegments("/v20190125/meshes/");
1150 uri.AddPathSegment(request.GetMeshName());
1151 uri.AddPathSegments("/virtualServices");
1152 return ListVirtualServicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1153 }
1154
ListVirtualServicesCallable(const ListVirtualServicesRequest & request) const1155 ListVirtualServicesOutcomeCallable AppMeshClient::ListVirtualServicesCallable(const ListVirtualServicesRequest& request) const
1156 {
1157 auto task = Aws::MakeShared< std::packaged_task< ListVirtualServicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVirtualServices(request); } );
1158 auto packagedFunction = [task]() { (*task)(); };
1159 m_executor->Submit(packagedFunction);
1160 return task->get_future();
1161 }
1162
ListVirtualServicesAsync(const ListVirtualServicesRequest & request,const ListVirtualServicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1163 void AppMeshClient::ListVirtualServicesAsync(const ListVirtualServicesRequest& request, const ListVirtualServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1164 {
1165 m_executor->Submit( [this, request, handler, context](){ this->ListVirtualServicesAsyncHelper( request, handler, context ); } );
1166 }
1167
ListVirtualServicesAsyncHelper(const ListVirtualServicesRequest & request,const ListVirtualServicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1168 void AppMeshClient::ListVirtualServicesAsyncHelper(const ListVirtualServicesRequest& request, const ListVirtualServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1169 {
1170 handler(this, request, ListVirtualServices(request), context);
1171 }
1172
TagResource(const TagResourceRequest & request) const1173 TagResourceOutcome AppMeshClient::TagResource(const TagResourceRequest& request) const
1174 {
1175 if (!request.ResourceArnHasBeenSet())
1176 {
1177 AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
1178 return TagResourceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1179 }
1180 Aws::Http::URI uri = m_uri;
1181 uri.AddPathSegments("/v20190125/tag");
1182 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1183 }
1184
TagResourceCallable(const TagResourceRequest & request) const1185 TagResourceOutcomeCallable AppMeshClient::TagResourceCallable(const TagResourceRequest& request) const
1186 {
1187 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1188 auto packagedFunction = [task]() { (*task)(); };
1189 m_executor->Submit(packagedFunction);
1190 return task->get_future();
1191 }
1192
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1193 void AppMeshClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1194 {
1195 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1196 }
1197
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1198 void AppMeshClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1199 {
1200 handler(this, request, TagResource(request), context);
1201 }
1202
UntagResource(const UntagResourceRequest & request) const1203 UntagResourceOutcome AppMeshClient::UntagResource(const UntagResourceRequest& request) const
1204 {
1205 if (!request.ResourceArnHasBeenSet())
1206 {
1207 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
1208 return UntagResourceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1209 }
1210 Aws::Http::URI uri = m_uri;
1211 uri.AddPathSegments("/v20190125/untag");
1212 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1213 }
1214
UntagResourceCallable(const UntagResourceRequest & request) const1215 UntagResourceOutcomeCallable AppMeshClient::UntagResourceCallable(const UntagResourceRequest& request) const
1216 {
1217 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1218 auto packagedFunction = [task]() { (*task)(); };
1219 m_executor->Submit(packagedFunction);
1220 return task->get_future();
1221 }
1222
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1223 void AppMeshClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1224 {
1225 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1226 }
1227
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1228 void AppMeshClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1229 {
1230 handler(this, request, UntagResource(request), context);
1231 }
1232
UpdateGatewayRoute(const UpdateGatewayRouteRequest & request) const1233 UpdateGatewayRouteOutcome AppMeshClient::UpdateGatewayRoute(const UpdateGatewayRouteRequest& request) const
1234 {
1235 if (!request.GatewayRouteNameHasBeenSet())
1236 {
1237 AWS_LOGSTREAM_ERROR("UpdateGatewayRoute", "Required field: GatewayRouteName, is not set");
1238 return UpdateGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [GatewayRouteName]", false));
1239 }
1240 if (!request.MeshNameHasBeenSet())
1241 {
1242 AWS_LOGSTREAM_ERROR("UpdateGatewayRoute", "Required field: MeshName, is not set");
1243 return UpdateGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1244 }
1245 if (!request.VirtualGatewayNameHasBeenSet())
1246 {
1247 AWS_LOGSTREAM_ERROR("UpdateGatewayRoute", "Required field: VirtualGatewayName, is not set");
1248 return UpdateGatewayRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
1249 }
1250 Aws::Http::URI uri = m_uri;
1251 uri.AddPathSegments("/v20190125/meshes/");
1252 uri.AddPathSegment(request.GetMeshName());
1253 uri.AddPathSegments("/virtualGateway/");
1254 uri.AddPathSegment(request.GetVirtualGatewayName());
1255 uri.AddPathSegments("/gatewayRoutes/");
1256 uri.AddPathSegment(request.GetGatewayRouteName());
1257 return UpdateGatewayRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1258 }
1259
UpdateGatewayRouteCallable(const UpdateGatewayRouteRequest & request) const1260 UpdateGatewayRouteOutcomeCallable AppMeshClient::UpdateGatewayRouteCallable(const UpdateGatewayRouteRequest& request) const
1261 {
1262 auto task = Aws::MakeShared< std::packaged_task< UpdateGatewayRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateGatewayRoute(request); } );
1263 auto packagedFunction = [task]() { (*task)(); };
1264 m_executor->Submit(packagedFunction);
1265 return task->get_future();
1266 }
1267
UpdateGatewayRouteAsync(const UpdateGatewayRouteRequest & request,const UpdateGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1268 void AppMeshClient::UpdateGatewayRouteAsync(const UpdateGatewayRouteRequest& request, const UpdateGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1269 {
1270 m_executor->Submit( [this, request, handler, context](){ this->UpdateGatewayRouteAsyncHelper( request, handler, context ); } );
1271 }
1272
UpdateGatewayRouteAsyncHelper(const UpdateGatewayRouteRequest & request,const UpdateGatewayRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1273 void AppMeshClient::UpdateGatewayRouteAsyncHelper(const UpdateGatewayRouteRequest& request, const UpdateGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1274 {
1275 handler(this, request, UpdateGatewayRoute(request), context);
1276 }
1277
UpdateMesh(const UpdateMeshRequest & request) const1278 UpdateMeshOutcome AppMeshClient::UpdateMesh(const UpdateMeshRequest& request) const
1279 {
1280 if (!request.MeshNameHasBeenSet())
1281 {
1282 AWS_LOGSTREAM_ERROR("UpdateMesh", "Required field: MeshName, is not set");
1283 return UpdateMeshOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1284 }
1285 Aws::Http::URI uri = m_uri;
1286 uri.AddPathSegments("/v20190125/meshes/");
1287 uri.AddPathSegment(request.GetMeshName());
1288 return UpdateMeshOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1289 }
1290
UpdateMeshCallable(const UpdateMeshRequest & request) const1291 UpdateMeshOutcomeCallable AppMeshClient::UpdateMeshCallable(const UpdateMeshRequest& request) const
1292 {
1293 auto task = Aws::MakeShared< std::packaged_task< UpdateMeshOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateMesh(request); } );
1294 auto packagedFunction = [task]() { (*task)(); };
1295 m_executor->Submit(packagedFunction);
1296 return task->get_future();
1297 }
1298
UpdateMeshAsync(const UpdateMeshRequest & request,const UpdateMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1299 void AppMeshClient::UpdateMeshAsync(const UpdateMeshRequest& request, const UpdateMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1300 {
1301 m_executor->Submit( [this, request, handler, context](){ this->UpdateMeshAsyncHelper( request, handler, context ); } );
1302 }
1303
UpdateMeshAsyncHelper(const UpdateMeshRequest & request,const UpdateMeshResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1304 void AppMeshClient::UpdateMeshAsyncHelper(const UpdateMeshRequest& request, const UpdateMeshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1305 {
1306 handler(this, request, UpdateMesh(request), context);
1307 }
1308
UpdateRoute(const UpdateRouteRequest & request) const1309 UpdateRouteOutcome AppMeshClient::UpdateRoute(const UpdateRouteRequest& request) const
1310 {
1311 if (!request.MeshNameHasBeenSet())
1312 {
1313 AWS_LOGSTREAM_ERROR("UpdateRoute", "Required field: MeshName, is not set");
1314 return UpdateRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1315 }
1316 if (!request.RouteNameHasBeenSet())
1317 {
1318 AWS_LOGSTREAM_ERROR("UpdateRoute", "Required field: RouteName, is not set");
1319 return UpdateRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RouteName]", false));
1320 }
1321 if (!request.VirtualRouterNameHasBeenSet())
1322 {
1323 AWS_LOGSTREAM_ERROR("UpdateRoute", "Required field: VirtualRouterName, is not set");
1324 return UpdateRouteOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
1325 }
1326 Aws::Http::URI uri = m_uri;
1327 uri.AddPathSegments("/v20190125/meshes/");
1328 uri.AddPathSegment(request.GetMeshName());
1329 uri.AddPathSegments("/virtualRouter/");
1330 uri.AddPathSegment(request.GetVirtualRouterName());
1331 uri.AddPathSegments("/routes/");
1332 uri.AddPathSegment(request.GetRouteName());
1333 return UpdateRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1334 }
1335
UpdateRouteCallable(const UpdateRouteRequest & request) const1336 UpdateRouteOutcomeCallable AppMeshClient::UpdateRouteCallable(const UpdateRouteRequest& request) const
1337 {
1338 auto task = Aws::MakeShared< std::packaged_task< UpdateRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoute(request); } );
1339 auto packagedFunction = [task]() { (*task)(); };
1340 m_executor->Submit(packagedFunction);
1341 return task->get_future();
1342 }
1343
UpdateRouteAsync(const UpdateRouteRequest & request,const UpdateRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1344 void AppMeshClient::UpdateRouteAsync(const UpdateRouteRequest& request, const UpdateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1345 {
1346 m_executor->Submit( [this, request, handler, context](){ this->UpdateRouteAsyncHelper( request, handler, context ); } );
1347 }
1348
UpdateRouteAsyncHelper(const UpdateRouteRequest & request,const UpdateRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1349 void AppMeshClient::UpdateRouteAsyncHelper(const UpdateRouteRequest& request, const UpdateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1350 {
1351 handler(this, request, UpdateRoute(request), context);
1352 }
1353
UpdateVirtualGateway(const UpdateVirtualGatewayRequest & request) const1354 UpdateVirtualGatewayOutcome AppMeshClient::UpdateVirtualGateway(const UpdateVirtualGatewayRequest& request) const
1355 {
1356 if (!request.MeshNameHasBeenSet())
1357 {
1358 AWS_LOGSTREAM_ERROR("UpdateVirtualGateway", "Required field: MeshName, is not set");
1359 return UpdateVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1360 }
1361 if (!request.VirtualGatewayNameHasBeenSet())
1362 {
1363 AWS_LOGSTREAM_ERROR("UpdateVirtualGateway", "Required field: VirtualGatewayName, is not set");
1364 return UpdateVirtualGatewayOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualGatewayName]", false));
1365 }
1366 Aws::Http::URI uri = m_uri;
1367 uri.AddPathSegments("/v20190125/meshes/");
1368 uri.AddPathSegment(request.GetMeshName());
1369 uri.AddPathSegments("/virtualGateways/");
1370 uri.AddPathSegment(request.GetVirtualGatewayName());
1371 return UpdateVirtualGatewayOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1372 }
1373
UpdateVirtualGatewayCallable(const UpdateVirtualGatewayRequest & request) const1374 UpdateVirtualGatewayOutcomeCallable AppMeshClient::UpdateVirtualGatewayCallable(const UpdateVirtualGatewayRequest& request) const
1375 {
1376 auto task = Aws::MakeShared< std::packaged_task< UpdateVirtualGatewayOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateVirtualGateway(request); } );
1377 auto packagedFunction = [task]() { (*task)(); };
1378 m_executor->Submit(packagedFunction);
1379 return task->get_future();
1380 }
1381
UpdateVirtualGatewayAsync(const UpdateVirtualGatewayRequest & request,const UpdateVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1382 void AppMeshClient::UpdateVirtualGatewayAsync(const UpdateVirtualGatewayRequest& request, const UpdateVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1383 {
1384 m_executor->Submit( [this, request, handler, context](){ this->UpdateVirtualGatewayAsyncHelper( request, handler, context ); } );
1385 }
1386
UpdateVirtualGatewayAsyncHelper(const UpdateVirtualGatewayRequest & request,const UpdateVirtualGatewayResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1387 void AppMeshClient::UpdateVirtualGatewayAsyncHelper(const UpdateVirtualGatewayRequest& request, const UpdateVirtualGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1388 {
1389 handler(this, request, UpdateVirtualGateway(request), context);
1390 }
1391
UpdateVirtualNode(const UpdateVirtualNodeRequest & request) const1392 UpdateVirtualNodeOutcome AppMeshClient::UpdateVirtualNode(const UpdateVirtualNodeRequest& request) const
1393 {
1394 if (!request.MeshNameHasBeenSet())
1395 {
1396 AWS_LOGSTREAM_ERROR("UpdateVirtualNode", "Required field: MeshName, is not set");
1397 return UpdateVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1398 }
1399 if (!request.VirtualNodeNameHasBeenSet())
1400 {
1401 AWS_LOGSTREAM_ERROR("UpdateVirtualNode", "Required field: VirtualNodeName, is not set");
1402 return UpdateVirtualNodeOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualNodeName]", false));
1403 }
1404 Aws::Http::URI uri = m_uri;
1405 uri.AddPathSegments("/v20190125/meshes/");
1406 uri.AddPathSegment(request.GetMeshName());
1407 uri.AddPathSegments("/virtualNodes/");
1408 uri.AddPathSegment(request.GetVirtualNodeName());
1409 return UpdateVirtualNodeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1410 }
1411
UpdateVirtualNodeCallable(const UpdateVirtualNodeRequest & request) const1412 UpdateVirtualNodeOutcomeCallable AppMeshClient::UpdateVirtualNodeCallable(const UpdateVirtualNodeRequest& request) const
1413 {
1414 auto task = Aws::MakeShared< std::packaged_task< UpdateVirtualNodeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateVirtualNode(request); } );
1415 auto packagedFunction = [task]() { (*task)(); };
1416 m_executor->Submit(packagedFunction);
1417 return task->get_future();
1418 }
1419
UpdateVirtualNodeAsync(const UpdateVirtualNodeRequest & request,const UpdateVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1420 void AppMeshClient::UpdateVirtualNodeAsync(const UpdateVirtualNodeRequest& request, const UpdateVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1421 {
1422 m_executor->Submit( [this, request, handler, context](){ this->UpdateVirtualNodeAsyncHelper( request, handler, context ); } );
1423 }
1424
UpdateVirtualNodeAsyncHelper(const UpdateVirtualNodeRequest & request,const UpdateVirtualNodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1425 void AppMeshClient::UpdateVirtualNodeAsyncHelper(const UpdateVirtualNodeRequest& request, const UpdateVirtualNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1426 {
1427 handler(this, request, UpdateVirtualNode(request), context);
1428 }
1429
UpdateVirtualRouter(const UpdateVirtualRouterRequest & request) const1430 UpdateVirtualRouterOutcome AppMeshClient::UpdateVirtualRouter(const UpdateVirtualRouterRequest& request) const
1431 {
1432 if (!request.MeshNameHasBeenSet())
1433 {
1434 AWS_LOGSTREAM_ERROR("UpdateVirtualRouter", "Required field: MeshName, is not set");
1435 return UpdateVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1436 }
1437 if (!request.VirtualRouterNameHasBeenSet())
1438 {
1439 AWS_LOGSTREAM_ERROR("UpdateVirtualRouter", "Required field: VirtualRouterName, is not set");
1440 return UpdateVirtualRouterOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualRouterName]", false));
1441 }
1442 Aws::Http::URI uri = m_uri;
1443 uri.AddPathSegments("/v20190125/meshes/");
1444 uri.AddPathSegment(request.GetMeshName());
1445 uri.AddPathSegments("/virtualRouters/");
1446 uri.AddPathSegment(request.GetVirtualRouterName());
1447 return UpdateVirtualRouterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1448 }
1449
UpdateVirtualRouterCallable(const UpdateVirtualRouterRequest & request) const1450 UpdateVirtualRouterOutcomeCallable AppMeshClient::UpdateVirtualRouterCallable(const UpdateVirtualRouterRequest& request) const
1451 {
1452 auto task = Aws::MakeShared< std::packaged_task< UpdateVirtualRouterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateVirtualRouter(request); } );
1453 auto packagedFunction = [task]() { (*task)(); };
1454 m_executor->Submit(packagedFunction);
1455 return task->get_future();
1456 }
1457
UpdateVirtualRouterAsync(const UpdateVirtualRouterRequest & request,const UpdateVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1458 void AppMeshClient::UpdateVirtualRouterAsync(const UpdateVirtualRouterRequest& request, const UpdateVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1459 {
1460 m_executor->Submit( [this, request, handler, context](){ this->UpdateVirtualRouterAsyncHelper( request, handler, context ); } );
1461 }
1462
UpdateVirtualRouterAsyncHelper(const UpdateVirtualRouterRequest & request,const UpdateVirtualRouterResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1463 void AppMeshClient::UpdateVirtualRouterAsyncHelper(const UpdateVirtualRouterRequest& request, const UpdateVirtualRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1464 {
1465 handler(this, request, UpdateVirtualRouter(request), context);
1466 }
1467
UpdateVirtualService(const UpdateVirtualServiceRequest & request) const1468 UpdateVirtualServiceOutcome AppMeshClient::UpdateVirtualService(const UpdateVirtualServiceRequest& request) const
1469 {
1470 if (!request.MeshNameHasBeenSet())
1471 {
1472 AWS_LOGSTREAM_ERROR("UpdateVirtualService", "Required field: MeshName, is not set");
1473 return UpdateVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeshName]", false));
1474 }
1475 if (!request.VirtualServiceNameHasBeenSet())
1476 {
1477 AWS_LOGSTREAM_ERROR("UpdateVirtualService", "Required field: VirtualServiceName, is not set");
1478 return UpdateVirtualServiceOutcome(Aws::Client::AWSError<AppMeshErrors>(AppMeshErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VirtualServiceName]", false));
1479 }
1480 Aws::Http::URI uri = m_uri;
1481 uri.AddPathSegments("/v20190125/meshes/");
1482 uri.AddPathSegment(request.GetMeshName());
1483 uri.AddPathSegments("/virtualServices/");
1484 uri.AddPathSegment(request.GetVirtualServiceName());
1485 return UpdateVirtualServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1486 }
1487
UpdateVirtualServiceCallable(const UpdateVirtualServiceRequest & request) const1488 UpdateVirtualServiceOutcomeCallable AppMeshClient::UpdateVirtualServiceCallable(const UpdateVirtualServiceRequest& request) const
1489 {
1490 auto task = Aws::MakeShared< std::packaged_task< UpdateVirtualServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateVirtualService(request); } );
1491 auto packagedFunction = [task]() { (*task)(); };
1492 m_executor->Submit(packagedFunction);
1493 return task->get_future();
1494 }
1495
UpdateVirtualServiceAsync(const UpdateVirtualServiceRequest & request,const UpdateVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1496 void AppMeshClient::UpdateVirtualServiceAsync(const UpdateVirtualServiceRequest& request, const UpdateVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1497 {
1498 m_executor->Submit( [this, request, handler, context](){ this->UpdateVirtualServiceAsyncHelper( request, handler, context ); } );
1499 }
1500
UpdateVirtualServiceAsyncHelper(const UpdateVirtualServiceRequest & request,const UpdateVirtualServiceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1501 void AppMeshClient::UpdateVirtualServiceAsyncHelper(const UpdateVirtualServiceRequest& request, const UpdateVirtualServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1502 {
1503 handler(this, request, UpdateVirtualService(request), context);
1504 }
1505
1506