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/appconfig/AppConfigClient.h>
21 #include <aws/appconfig/AppConfigEndpoint.h>
22 #include <aws/appconfig/AppConfigErrorMarshaller.h>
23 #include <aws/appconfig/model/CreateApplicationRequest.h>
24 #include <aws/appconfig/model/CreateConfigurationProfileRequest.h>
25 #include <aws/appconfig/model/CreateDeploymentStrategyRequest.h>
26 #include <aws/appconfig/model/CreateEnvironmentRequest.h>
27 #include <aws/appconfig/model/CreateHostedConfigurationVersionRequest.h>
28 #include <aws/appconfig/model/DeleteApplicationRequest.h>
29 #include <aws/appconfig/model/DeleteConfigurationProfileRequest.h>
30 #include <aws/appconfig/model/DeleteDeploymentStrategyRequest.h>
31 #include <aws/appconfig/model/DeleteEnvironmentRequest.h>
32 #include <aws/appconfig/model/DeleteHostedConfigurationVersionRequest.h>
33 #include <aws/appconfig/model/GetApplicationRequest.h>
34 #include <aws/appconfig/model/GetConfigurationRequest.h>
35 #include <aws/appconfig/model/GetConfigurationProfileRequest.h>
36 #include <aws/appconfig/model/GetDeploymentRequest.h>
37 #include <aws/appconfig/model/GetDeploymentStrategyRequest.h>
38 #include <aws/appconfig/model/GetEnvironmentRequest.h>
39 #include <aws/appconfig/model/GetHostedConfigurationVersionRequest.h>
40 #include <aws/appconfig/model/ListApplicationsRequest.h>
41 #include <aws/appconfig/model/ListConfigurationProfilesRequest.h>
42 #include <aws/appconfig/model/ListDeploymentStrategiesRequest.h>
43 #include <aws/appconfig/model/ListDeploymentsRequest.h>
44 #include <aws/appconfig/model/ListEnvironmentsRequest.h>
45 #include <aws/appconfig/model/ListHostedConfigurationVersionsRequest.h>
46 #include <aws/appconfig/model/ListTagsForResourceRequest.h>
47 #include <aws/appconfig/model/StartDeploymentRequest.h>
48 #include <aws/appconfig/model/StopDeploymentRequest.h>
49 #include <aws/appconfig/model/TagResourceRequest.h>
50 #include <aws/appconfig/model/UntagResourceRequest.h>
51 #include <aws/appconfig/model/UpdateApplicationRequest.h>
52 #include <aws/appconfig/model/UpdateConfigurationProfileRequest.h>
53 #include <aws/appconfig/model/UpdateDeploymentStrategyRequest.h>
54 #include <aws/appconfig/model/UpdateEnvironmentRequest.h>
55 #include <aws/appconfig/model/ValidateConfigurationRequest.h>
56
57 using namespace Aws;
58 using namespace Aws::Auth;
59 using namespace Aws::Client;
60 using namespace Aws::AppConfig;
61 using namespace Aws::AppConfig::Model;
62 using namespace Aws::Http;
63 using namespace Aws::Utils::Json;
64
65 static const char* SERVICE_NAME = "appconfig";
66 static const char* ALLOCATION_TAG = "AppConfigClient";
67
68
AppConfigClient(const Client::ClientConfiguration & clientConfiguration)69 AppConfigClient::AppConfigClient(const Client::ClientConfiguration& clientConfiguration) :
70 BASECLASS(clientConfiguration,
71 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
72 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
73 Aws::MakeShared<AppConfigErrorMarshaller>(ALLOCATION_TAG)),
74 m_executor(clientConfiguration.executor)
75 {
76 init(clientConfiguration);
77 }
78
AppConfigClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)79 AppConfigClient::AppConfigClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
80 BASECLASS(clientConfiguration,
81 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
82 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
83 Aws::MakeShared<AppConfigErrorMarshaller>(ALLOCATION_TAG)),
84 m_executor(clientConfiguration.executor)
85 {
86 init(clientConfiguration);
87 }
88
AppConfigClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)89 AppConfigClient::AppConfigClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
90 const Client::ClientConfiguration& clientConfiguration) :
91 BASECLASS(clientConfiguration,
92 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
93 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
94 Aws::MakeShared<AppConfigErrorMarshaller>(ALLOCATION_TAG)),
95 m_executor(clientConfiguration.executor)
96 {
97 init(clientConfiguration);
98 }
99
~AppConfigClient()100 AppConfigClient::~AppConfigClient()
101 {
102 }
103
init(const Client::ClientConfiguration & config)104 void AppConfigClient::init(const Client::ClientConfiguration& config)
105 {
106 SetServiceClientName("AppConfig");
107 m_configScheme = SchemeMapper::ToString(config.scheme);
108 if (config.endpointOverride.empty())
109 {
110 m_uri = m_configScheme + "://" + AppConfigEndpoint::ForRegion(config.region, config.useDualStack);
111 }
112 else
113 {
114 OverrideEndpoint(config.endpointOverride);
115 }
116 }
117
OverrideEndpoint(const Aws::String & endpoint)118 void AppConfigClient::OverrideEndpoint(const Aws::String& endpoint)
119 {
120 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
121 {
122 m_uri = endpoint;
123 }
124 else
125 {
126 m_uri = m_configScheme + "://" + endpoint;
127 }
128 }
129
CreateApplication(const CreateApplicationRequest & request) const130 CreateApplicationOutcome AppConfigClient::CreateApplication(const CreateApplicationRequest& request) const
131 {
132 Aws::Http::URI uri = m_uri;
133 uri.AddPathSegments("/applications");
134 return CreateApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
135 }
136
CreateApplicationCallable(const CreateApplicationRequest & request) const137 CreateApplicationOutcomeCallable AppConfigClient::CreateApplicationCallable(const CreateApplicationRequest& request) const
138 {
139 auto task = Aws::MakeShared< std::packaged_task< CreateApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateApplication(request); } );
140 auto packagedFunction = [task]() { (*task)(); };
141 m_executor->Submit(packagedFunction);
142 return task->get_future();
143 }
144
CreateApplicationAsync(const CreateApplicationRequest & request,const CreateApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const145 void AppConfigClient::CreateApplicationAsync(const CreateApplicationRequest& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
146 {
147 m_executor->Submit( [this, request, handler, context](){ this->CreateApplicationAsyncHelper( request, handler, context ); } );
148 }
149
CreateApplicationAsyncHelper(const CreateApplicationRequest & request,const CreateApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const150 void AppConfigClient::CreateApplicationAsyncHelper(const CreateApplicationRequest& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
151 {
152 handler(this, request, CreateApplication(request), context);
153 }
154
CreateConfigurationProfile(const CreateConfigurationProfileRequest & request) const155 CreateConfigurationProfileOutcome AppConfigClient::CreateConfigurationProfile(const CreateConfigurationProfileRequest& request) const
156 {
157 if (!request.ApplicationIdHasBeenSet())
158 {
159 AWS_LOGSTREAM_ERROR("CreateConfigurationProfile", "Required field: ApplicationId, is not set");
160 return CreateConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
161 }
162 Aws::Http::URI uri = m_uri;
163 uri.AddPathSegments("/applications/");
164 uri.AddPathSegment(request.GetApplicationId());
165 uri.AddPathSegments("/configurationprofiles");
166 return CreateConfigurationProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
167 }
168
CreateConfigurationProfileCallable(const CreateConfigurationProfileRequest & request) const169 CreateConfigurationProfileOutcomeCallable AppConfigClient::CreateConfigurationProfileCallable(const CreateConfigurationProfileRequest& request) const
170 {
171 auto task = Aws::MakeShared< std::packaged_task< CreateConfigurationProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateConfigurationProfile(request); } );
172 auto packagedFunction = [task]() { (*task)(); };
173 m_executor->Submit(packagedFunction);
174 return task->get_future();
175 }
176
CreateConfigurationProfileAsync(const CreateConfigurationProfileRequest & request,const CreateConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const177 void AppConfigClient::CreateConfigurationProfileAsync(const CreateConfigurationProfileRequest& request, const CreateConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
178 {
179 m_executor->Submit( [this, request, handler, context](){ this->CreateConfigurationProfileAsyncHelper( request, handler, context ); } );
180 }
181
CreateConfigurationProfileAsyncHelper(const CreateConfigurationProfileRequest & request,const CreateConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const182 void AppConfigClient::CreateConfigurationProfileAsyncHelper(const CreateConfigurationProfileRequest& request, const CreateConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
183 {
184 handler(this, request, CreateConfigurationProfile(request), context);
185 }
186
CreateDeploymentStrategy(const CreateDeploymentStrategyRequest & request) const187 CreateDeploymentStrategyOutcome AppConfigClient::CreateDeploymentStrategy(const CreateDeploymentStrategyRequest& request) const
188 {
189 Aws::Http::URI uri = m_uri;
190 uri.AddPathSegments("/deploymentstrategies");
191 return CreateDeploymentStrategyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
192 }
193
CreateDeploymentStrategyCallable(const CreateDeploymentStrategyRequest & request) const194 CreateDeploymentStrategyOutcomeCallable AppConfigClient::CreateDeploymentStrategyCallable(const CreateDeploymentStrategyRequest& request) const
195 {
196 auto task = Aws::MakeShared< std::packaged_task< CreateDeploymentStrategyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateDeploymentStrategy(request); } );
197 auto packagedFunction = [task]() { (*task)(); };
198 m_executor->Submit(packagedFunction);
199 return task->get_future();
200 }
201
CreateDeploymentStrategyAsync(const CreateDeploymentStrategyRequest & request,const CreateDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const202 void AppConfigClient::CreateDeploymentStrategyAsync(const CreateDeploymentStrategyRequest& request, const CreateDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
203 {
204 m_executor->Submit( [this, request, handler, context](){ this->CreateDeploymentStrategyAsyncHelper( request, handler, context ); } );
205 }
206
CreateDeploymentStrategyAsyncHelper(const CreateDeploymentStrategyRequest & request,const CreateDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const207 void AppConfigClient::CreateDeploymentStrategyAsyncHelper(const CreateDeploymentStrategyRequest& request, const CreateDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
208 {
209 handler(this, request, CreateDeploymentStrategy(request), context);
210 }
211
CreateEnvironment(const CreateEnvironmentRequest & request) const212 CreateEnvironmentOutcome AppConfigClient::CreateEnvironment(const CreateEnvironmentRequest& request) const
213 {
214 if (!request.ApplicationIdHasBeenSet())
215 {
216 AWS_LOGSTREAM_ERROR("CreateEnvironment", "Required field: ApplicationId, is not set");
217 return CreateEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
218 }
219 Aws::Http::URI uri = m_uri;
220 uri.AddPathSegments("/applications/");
221 uri.AddPathSegment(request.GetApplicationId());
222 uri.AddPathSegments("/environments");
223 return CreateEnvironmentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
224 }
225
CreateEnvironmentCallable(const CreateEnvironmentRequest & request) const226 CreateEnvironmentOutcomeCallable AppConfigClient::CreateEnvironmentCallable(const CreateEnvironmentRequest& request) const
227 {
228 auto task = Aws::MakeShared< std::packaged_task< CreateEnvironmentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateEnvironment(request); } );
229 auto packagedFunction = [task]() { (*task)(); };
230 m_executor->Submit(packagedFunction);
231 return task->get_future();
232 }
233
CreateEnvironmentAsync(const CreateEnvironmentRequest & request,const CreateEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const234 void AppConfigClient::CreateEnvironmentAsync(const CreateEnvironmentRequest& request, const CreateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
235 {
236 m_executor->Submit( [this, request, handler, context](){ this->CreateEnvironmentAsyncHelper( request, handler, context ); } );
237 }
238
CreateEnvironmentAsyncHelper(const CreateEnvironmentRequest & request,const CreateEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const239 void AppConfigClient::CreateEnvironmentAsyncHelper(const CreateEnvironmentRequest& request, const CreateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
240 {
241 handler(this, request, CreateEnvironment(request), context);
242 }
243
CreateHostedConfigurationVersion(const CreateHostedConfigurationVersionRequest & request) const244 CreateHostedConfigurationVersionOutcome AppConfigClient::CreateHostedConfigurationVersion(const CreateHostedConfigurationVersionRequest& request) const
245 {
246 if (!request.ApplicationIdHasBeenSet())
247 {
248 AWS_LOGSTREAM_ERROR("CreateHostedConfigurationVersion", "Required field: ApplicationId, is not set");
249 return CreateHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
250 }
251 if (!request.ConfigurationProfileIdHasBeenSet())
252 {
253 AWS_LOGSTREAM_ERROR("CreateHostedConfigurationVersion", "Required field: ConfigurationProfileId, is not set");
254 return CreateHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
255 }
256 Aws::Http::URI uri = m_uri;
257 uri.AddPathSegments("/applications/");
258 uri.AddPathSegment(request.GetApplicationId());
259 uri.AddPathSegments("/configurationprofiles/");
260 uri.AddPathSegment(request.GetConfigurationProfileId());
261 uri.AddPathSegments("/hostedconfigurationversions");
262 return CreateHostedConfigurationVersionOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_POST));
263 }
264
CreateHostedConfigurationVersionCallable(const CreateHostedConfigurationVersionRequest & request) const265 CreateHostedConfigurationVersionOutcomeCallable AppConfigClient::CreateHostedConfigurationVersionCallable(const CreateHostedConfigurationVersionRequest& request) const
266 {
267 auto task = Aws::MakeShared< std::packaged_task< CreateHostedConfigurationVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateHostedConfigurationVersion(request); } );
268 auto packagedFunction = [task]() { (*task)(); };
269 m_executor->Submit(packagedFunction);
270 return task->get_future();
271 }
272
CreateHostedConfigurationVersionAsync(const CreateHostedConfigurationVersionRequest & request,const CreateHostedConfigurationVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const273 void AppConfigClient::CreateHostedConfigurationVersionAsync(const CreateHostedConfigurationVersionRequest& request, const CreateHostedConfigurationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
274 {
275 m_executor->Submit( [this, request, handler, context](){ this->CreateHostedConfigurationVersionAsyncHelper( request, handler, context ); } );
276 }
277
CreateHostedConfigurationVersionAsyncHelper(const CreateHostedConfigurationVersionRequest & request,const CreateHostedConfigurationVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const278 void AppConfigClient::CreateHostedConfigurationVersionAsyncHelper(const CreateHostedConfigurationVersionRequest& request, const CreateHostedConfigurationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
279 {
280 handler(this, request, CreateHostedConfigurationVersion(request), context);
281 }
282
DeleteApplication(const DeleteApplicationRequest & request) const283 DeleteApplicationOutcome AppConfigClient::DeleteApplication(const DeleteApplicationRequest& request) const
284 {
285 if (!request.ApplicationIdHasBeenSet())
286 {
287 AWS_LOGSTREAM_ERROR("DeleteApplication", "Required field: ApplicationId, is not set");
288 return DeleteApplicationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
289 }
290 Aws::Http::URI uri = m_uri;
291 uri.AddPathSegments("/applications/");
292 uri.AddPathSegment(request.GetApplicationId());
293 return DeleteApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
294 }
295
DeleteApplicationCallable(const DeleteApplicationRequest & request) const296 DeleteApplicationOutcomeCallable AppConfigClient::DeleteApplicationCallable(const DeleteApplicationRequest& request) const
297 {
298 auto task = Aws::MakeShared< std::packaged_task< DeleteApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteApplication(request); } );
299 auto packagedFunction = [task]() { (*task)(); };
300 m_executor->Submit(packagedFunction);
301 return task->get_future();
302 }
303
DeleteApplicationAsync(const DeleteApplicationRequest & request,const DeleteApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const304 void AppConfigClient::DeleteApplicationAsync(const DeleteApplicationRequest& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
305 {
306 m_executor->Submit( [this, request, handler, context](){ this->DeleteApplicationAsyncHelper( request, handler, context ); } );
307 }
308
DeleteApplicationAsyncHelper(const DeleteApplicationRequest & request,const DeleteApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const309 void AppConfigClient::DeleteApplicationAsyncHelper(const DeleteApplicationRequest& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
310 {
311 handler(this, request, DeleteApplication(request), context);
312 }
313
DeleteConfigurationProfile(const DeleteConfigurationProfileRequest & request) const314 DeleteConfigurationProfileOutcome AppConfigClient::DeleteConfigurationProfile(const DeleteConfigurationProfileRequest& request) const
315 {
316 if (!request.ApplicationIdHasBeenSet())
317 {
318 AWS_LOGSTREAM_ERROR("DeleteConfigurationProfile", "Required field: ApplicationId, is not set");
319 return DeleteConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
320 }
321 if (!request.ConfigurationProfileIdHasBeenSet())
322 {
323 AWS_LOGSTREAM_ERROR("DeleteConfigurationProfile", "Required field: ConfigurationProfileId, is not set");
324 return DeleteConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
325 }
326 Aws::Http::URI uri = m_uri;
327 uri.AddPathSegments("/applications/");
328 uri.AddPathSegment(request.GetApplicationId());
329 uri.AddPathSegments("/configurationprofiles/");
330 uri.AddPathSegment(request.GetConfigurationProfileId());
331 return DeleteConfigurationProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
332 }
333
DeleteConfigurationProfileCallable(const DeleteConfigurationProfileRequest & request) const334 DeleteConfigurationProfileOutcomeCallable AppConfigClient::DeleteConfigurationProfileCallable(const DeleteConfigurationProfileRequest& request) const
335 {
336 auto task = Aws::MakeShared< std::packaged_task< DeleteConfigurationProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteConfigurationProfile(request); } );
337 auto packagedFunction = [task]() { (*task)(); };
338 m_executor->Submit(packagedFunction);
339 return task->get_future();
340 }
341
DeleteConfigurationProfileAsync(const DeleteConfigurationProfileRequest & request,const DeleteConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const342 void AppConfigClient::DeleteConfigurationProfileAsync(const DeleteConfigurationProfileRequest& request, const DeleteConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
343 {
344 m_executor->Submit( [this, request, handler, context](){ this->DeleteConfigurationProfileAsyncHelper( request, handler, context ); } );
345 }
346
DeleteConfigurationProfileAsyncHelper(const DeleteConfigurationProfileRequest & request,const DeleteConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const347 void AppConfigClient::DeleteConfigurationProfileAsyncHelper(const DeleteConfigurationProfileRequest& request, const DeleteConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
348 {
349 handler(this, request, DeleteConfigurationProfile(request), context);
350 }
351
DeleteDeploymentStrategy(const DeleteDeploymentStrategyRequest & request) const352 DeleteDeploymentStrategyOutcome AppConfigClient::DeleteDeploymentStrategy(const DeleteDeploymentStrategyRequest& request) const
353 {
354 if (!request.DeploymentStrategyIdHasBeenSet())
355 {
356 AWS_LOGSTREAM_ERROR("DeleteDeploymentStrategy", "Required field: DeploymentStrategyId, is not set");
357 return DeleteDeploymentStrategyOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeploymentStrategyId]", false));
358 }
359 Aws::Http::URI uri = m_uri;
360 uri.AddPathSegments("/deployementstrategies/");
361 uri.AddPathSegment(request.GetDeploymentStrategyId());
362 return DeleteDeploymentStrategyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
363 }
364
DeleteDeploymentStrategyCallable(const DeleteDeploymentStrategyRequest & request) const365 DeleteDeploymentStrategyOutcomeCallable AppConfigClient::DeleteDeploymentStrategyCallable(const DeleteDeploymentStrategyRequest& request) const
366 {
367 auto task = Aws::MakeShared< std::packaged_task< DeleteDeploymentStrategyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteDeploymentStrategy(request); } );
368 auto packagedFunction = [task]() { (*task)(); };
369 m_executor->Submit(packagedFunction);
370 return task->get_future();
371 }
372
DeleteDeploymentStrategyAsync(const DeleteDeploymentStrategyRequest & request,const DeleteDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const373 void AppConfigClient::DeleteDeploymentStrategyAsync(const DeleteDeploymentStrategyRequest& request, const DeleteDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
374 {
375 m_executor->Submit( [this, request, handler, context](){ this->DeleteDeploymentStrategyAsyncHelper( request, handler, context ); } );
376 }
377
DeleteDeploymentStrategyAsyncHelper(const DeleteDeploymentStrategyRequest & request,const DeleteDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const378 void AppConfigClient::DeleteDeploymentStrategyAsyncHelper(const DeleteDeploymentStrategyRequest& request, const DeleteDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
379 {
380 handler(this, request, DeleteDeploymentStrategy(request), context);
381 }
382
DeleteEnvironment(const DeleteEnvironmentRequest & request) const383 DeleteEnvironmentOutcome AppConfigClient::DeleteEnvironment(const DeleteEnvironmentRequest& request) const
384 {
385 if (!request.ApplicationIdHasBeenSet())
386 {
387 AWS_LOGSTREAM_ERROR("DeleteEnvironment", "Required field: ApplicationId, is not set");
388 return DeleteEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
389 }
390 if (!request.EnvironmentIdHasBeenSet())
391 {
392 AWS_LOGSTREAM_ERROR("DeleteEnvironment", "Required field: EnvironmentId, is not set");
393 return DeleteEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
394 }
395 Aws::Http::URI uri = m_uri;
396 uri.AddPathSegments("/applications/");
397 uri.AddPathSegment(request.GetApplicationId());
398 uri.AddPathSegments("/environments/");
399 uri.AddPathSegment(request.GetEnvironmentId());
400 return DeleteEnvironmentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
401 }
402
DeleteEnvironmentCallable(const DeleteEnvironmentRequest & request) const403 DeleteEnvironmentOutcomeCallable AppConfigClient::DeleteEnvironmentCallable(const DeleteEnvironmentRequest& request) const
404 {
405 auto task = Aws::MakeShared< std::packaged_task< DeleteEnvironmentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteEnvironment(request); } );
406 auto packagedFunction = [task]() { (*task)(); };
407 m_executor->Submit(packagedFunction);
408 return task->get_future();
409 }
410
DeleteEnvironmentAsync(const DeleteEnvironmentRequest & request,const DeleteEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const411 void AppConfigClient::DeleteEnvironmentAsync(const DeleteEnvironmentRequest& request, const DeleteEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
412 {
413 m_executor->Submit( [this, request, handler, context](){ this->DeleteEnvironmentAsyncHelper( request, handler, context ); } );
414 }
415
DeleteEnvironmentAsyncHelper(const DeleteEnvironmentRequest & request,const DeleteEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const416 void AppConfigClient::DeleteEnvironmentAsyncHelper(const DeleteEnvironmentRequest& request, const DeleteEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
417 {
418 handler(this, request, DeleteEnvironment(request), context);
419 }
420
DeleteHostedConfigurationVersion(const DeleteHostedConfigurationVersionRequest & request) const421 DeleteHostedConfigurationVersionOutcome AppConfigClient::DeleteHostedConfigurationVersion(const DeleteHostedConfigurationVersionRequest& request) const
422 {
423 if (!request.ApplicationIdHasBeenSet())
424 {
425 AWS_LOGSTREAM_ERROR("DeleteHostedConfigurationVersion", "Required field: ApplicationId, is not set");
426 return DeleteHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
427 }
428 if (!request.ConfigurationProfileIdHasBeenSet())
429 {
430 AWS_LOGSTREAM_ERROR("DeleteHostedConfigurationVersion", "Required field: ConfigurationProfileId, is not set");
431 return DeleteHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
432 }
433 if (!request.VersionNumberHasBeenSet())
434 {
435 AWS_LOGSTREAM_ERROR("DeleteHostedConfigurationVersion", "Required field: VersionNumber, is not set");
436 return DeleteHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
437 }
438 Aws::Http::URI uri = m_uri;
439 uri.AddPathSegments("/applications/");
440 uri.AddPathSegment(request.GetApplicationId());
441 uri.AddPathSegments("/configurationprofiles/");
442 uri.AddPathSegment(request.GetConfigurationProfileId());
443 uri.AddPathSegments("/hostedconfigurationversions/");
444 uri.AddPathSegment(request.GetVersionNumber());
445 return DeleteHostedConfigurationVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
446 }
447
DeleteHostedConfigurationVersionCallable(const DeleteHostedConfigurationVersionRequest & request) const448 DeleteHostedConfigurationVersionOutcomeCallable AppConfigClient::DeleteHostedConfigurationVersionCallable(const DeleteHostedConfigurationVersionRequest& request) const
449 {
450 auto task = Aws::MakeShared< std::packaged_task< DeleteHostedConfigurationVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteHostedConfigurationVersion(request); } );
451 auto packagedFunction = [task]() { (*task)(); };
452 m_executor->Submit(packagedFunction);
453 return task->get_future();
454 }
455
DeleteHostedConfigurationVersionAsync(const DeleteHostedConfigurationVersionRequest & request,const DeleteHostedConfigurationVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const456 void AppConfigClient::DeleteHostedConfigurationVersionAsync(const DeleteHostedConfigurationVersionRequest& request, const DeleteHostedConfigurationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
457 {
458 m_executor->Submit( [this, request, handler, context](){ this->DeleteHostedConfigurationVersionAsyncHelper( request, handler, context ); } );
459 }
460
DeleteHostedConfigurationVersionAsyncHelper(const DeleteHostedConfigurationVersionRequest & request,const DeleteHostedConfigurationVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const461 void AppConfigClient::DeleteHostedConfigurationVersionAsyncHelper(const DeleteHostedConfigurationVersionRequest& request, const DeleteHostedConfigurationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
462 {
463 handler(this, request, DeleteHostedConfigurationVersion(request), context);
464 }
465
GetApplication(const GetApplicationRequest & request) const466 GetApplicationOutcome AppConfigClient::GetApplication(const GetApplicationRequest& request) const
467 {
468 if (!request.ApplicationIdHasBeenSet())
469 {
470 AWS_LOGSTREAM_ERROR("GetApplication", "Required field: ApplicationId, is not set");
471 return GetApplicationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
472 }
473 Aws::Http::URI uri = m_uri;
474 uri.AddPathSegments("/applications/");
475 uri.AddPathSegment(request.GetApplicationId());
476 return GetApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
477 }
478
GetApplicationCallable(const GetApplicationRequest & request) const479 GetApplicationOutcomeCallable AppConfigClient::GetApplicationCallable(const GetApplicationRequest& request) const
480 {
481 auto task = Aws::MakeShared< std::packaged_task< GetApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetApplication(request); } );
482 auto packagedFunction = [task]() { (*task)(); };
483 m_executor->Submit(packagedFunction);
484 return task->get_future();
485 }
486
GetApplicationAsync(const GetApplicationRequest & request,const GetApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const487 void AppConfigClient::GetApplicationAsync(const GetApplicationRequest& request, const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
488 {
489 m_executor->Submit( [this, request, handler, context](){ this->GetApplicationAsyncHelper( request, handler, context ); } );
490 }
491
GetApplicationAsyncHelper(const GetApplicationRequest & request,const GetApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const492 void AppConfigClient::GetApplicationAsyncHelper(const GetApplicationRequest& request, const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
493 {
494 handler(this, request, GetApplication(request), context);
495 }
496
GetConfiguration(const GetConfigurationRequest & request) const497 GetConfigurationOutcome AppConfigClient::GetConfiguration(const GetConfigurationRequest& request) const
498 {
499 if (!request.ApplicationHasBeenSet())
500 {
501 AWS_LOGSTREAM_ERROR("GetConfiguration", "Required field: Application, is not set");
502 return GetConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Application]", false));
503 }
504 if (!request.EnvironmentHasBeenSet())
505 {
506 AWS_LOGSTREAM_ERROR("GetConfiguration", "Required field: Environment, is not set");
507 return GetConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Environment]", false));
508 }
509 if (!request.ConfigurationHasBeenSet())
510 {
511 AWS_LOGSTREAM_ERROR("GetConfiguration", "Required field: Configuration, is not set");
512 return GetConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Configuration]", false));
513 }
514 if (!request.ClientIdHasBeenSet())
515 {
516 AWS_LOGSTREAM_ERROR("GetConfiguration", "Required field: ClientId, is not set");
517 return GetConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ClientId]", false));
518 }
519 Aws::Http::URI uri = m_uri;
520 uri.AddPathSegments("/applications/");
521 uri.AddPathSegment(request.GetApplication());
522 uri.AddPathSegments("/environments/");
523 uri.AddPathSegment(request.GetEnvironment());
524 uri.AddPathSegments("/configurations/");
525 uri.AddPathSegment(request.GetConfiguration());
526 return GetConfigurationOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
527 }
528
GetConfigurationCallable(const GetConfigurationRequest & request) const529 GetConfigurationOutcomeCallable AppConfigClient::GetConfigurationCallable(const GetConfigurationRequest& request) const
530 {
531 auto task = Aws::MakeShared< std::packaged_task< GetConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetConfiguration(request); } );
532 auto packagedFunction = [task]() { (*task)(); };
533 m_executor->Submit(packagedFunction);
534 return task->get_future();
535 }
536
GetConfigurationAsync(const GetConfigurationRequest & request,const GetConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const537 void AppConfigClient::GetConfigurationAsync(const GetConfigurationRequest& request, const GetConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
538 {
539 m_executor->Submit( [this, request, handler, context](){ this->GetConfigurationAsyncHelper( request, handler, context ); } );
540 }
541
GetConfigurationAsyncHelper(const GetConfigurationRequest & request,const GetConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const542 void AppConfigClient::GetConfigurationAsyncHelper(const GetConfigurationRequest& request, const GetConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
543 {
544 handler(this, request, GetConfiguration(request), context);
545 }
546
GetConfigurationProfile(const GetConfigurationProfileRequest & request) const547 GetConfigurationProfileOutcome AppConfigClient::GetConfigurationProfile(const GetConfigurationProfileRequest& request) const
548 {
549 if (!request.ApplicationIdHasBeenSet())
550 {
551 AWS_LOGSTREAM_ERROR("GetConfigurationProfile", "Required field: ApplicationId, is not set");
552 return GetConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
553 }
554 if (!request.ConfigurationProfileIdHasBeenSet())
555 {
556 AWS_LOGSTREAM_ERROR("GetConfigurationProfile", "Required field: ConfigurationProfileId, is not set");
557 return GetConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
558 }
559 Aws::Http::URI uri = m_uri;
560 uri.AddPathSegments("/applications/");
561 uri.AddPathSegment(request.GetApplicationId());
562 uri.AddPathSegments("/configurationprofiles/");
563 uri.AddPathSegment(request.GetConfigurationProfileId());
564 return GetConfigurationProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
565 }
566
GetConfigurationProfileCallable(const GetConfigurationProfileRequest & request) const567 GetConfigurationProfileOutcomeCallable AppConfigClient::GetConfigurationProfileCallable(const GetConfigurationProfileRequest& request) const
568 {
569 auto task = Aws::MakeShared< std::packaged_task< GetConfigurationProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetConfigurationProfile(request); } );
570 auto packagedFunction = [task]() { (*task)(); };
571 m_executor->Submit(packagedFunction);
572 return task->get_future();
573 }
574
GetConfigurationProfileAsync(const GetConfigurationProfileRequest & request,const GetConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const575 void AppConfigClient::GetConfigurationProfileAsync(const GetConfigurationProfileRequest& request, const GetConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
576 {
577 m_executor->Submit( [this, request, handler, context](){ this->GetConfigurationProfileAsyncHelper( request, handler, context ); } );
578 }
579
GetConfigurationProfileAsyncHelper(const GetConfigurationProfileRequest & request,const GetConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const580 void AppConfigClient::GetConfigurationProfileAsyncHelper(const GetConfigurationProfileRequest& request, const GetConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
581 {
582 handler(this, request, GetConfigurationProfile(request), context);
583 }
584
GetDeployment(const GetDeploymentRequest & request) const585 GetDeploymentOutcome AppConfigClient::GetDeployment(const GetDeploymentRequest& request) const
586 {
587 if (!request.ApplicationIdHasBeenSet())
588 {
589 AWS_LOGSTREAM_ERROR("GetDeployment", "Required field: ApplicationId, is not set");
590 return GetDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
591 }
592 if (!request.EnvironmentIdHasBeenSet())
593 {
594 AWS_LOGSTREAM_ERROR("GetDeployment", "Required field: EnvironmentId, is not set");
595 return GetDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
596 }
597 if (!request.DeploymentNumberHasBeenSet())
598 {
599 AWS_LOGSTREAM_ERROR("GetDeployment", "Required field: DeploymentNumber, is not set");
600 return GetDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeploymentNumber]", false));
601 }
602 Aws::Http::URI uri = m_uri;
603 uri.AddPathSegments("/applications/");
604 uri.AddPathSegment(request.GetApplicationId());
605 uri.AddPathSegments("/environments/");
606 uri.AddPathSegment(request.GetEnvironmentId());
607 uri.AddPathSegments("/deployments/");
608 uri.AddPathSegment(request.GetDeploymentNumber());
609 return GetDeploymentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
610 }
611
GetDeploymentCallable(const GetDeploymentRequest & request) const612 GetDeploymentOutcomeCallable AppConfigClient::GetDeploymentCallable(const GetDeploymentRequest& request) const
613 {
614 auto task = Aws::MakeShared< std::packaged_task< GetDeploymentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetDeployment(request); } );
615 auto packagedFunction = [task]() { (*task)(); };
616 m_executor->Submit(packagedFunction);
617 return task->get_future();
618 }
619
GetDeploymentAsync(const GetDeploymentRequest & request,const GetDeploymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const620 void AppConfigClient::GetDeploymentAsync(const GetDeploymentRequest& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
621 {
622 m_executor->Submit( [this, request, handler, context](){ this->GetDeploymentAsyncHelper( request, handler, context ); } );
623 }
624
GetDeploymentAsyncHelper(const GetDeploymentRequest & request,const GetDeploymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const625 void AppConfigClient::GetDeploymentAsyncHelper(const GetDeploymentRequest& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
626 {
627 handler(this, request, GetDeployment(request), context);
628 }
629
GetDeploymentStrategy(const GetDeploymentStrategyRequest & request) const630 GetDeploymentStrategyOutcome AppConfigClient::GetDeploymentStrategy(const GetDeploymentStrategyRequest& request) const
631 {
632 if (!request.DeploymentStrategyIdHasBeenSet())
633 {
634 AWS_LOGSTREAM_ERROR("GetDeploymentStrategy", "Required field: DeploymentStrategyId, is not set");
635 return GetDeploymentStrategyOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeploymentStrategyId]", false));
636 }
637 Aws::Http::URI uri = m_uri;
638 uri.AddPathSegments("/deploymentstrategies/");
639 uri.AddPathSegment(request.GetDeploymentStrategyId());
640 return GetDeploymentStrategyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
641 }
642
GetDeploymentStrategyCallable(const GetDeploymentStrategyRequest & request) const643 GetDeploymentStrategyOutcomeCallable AppConfigClient::GetDeploymentStrategyCallable(const GetDeploymentStrategyRequest& request) const
644 {
645 auto task = Aws::MakeShared< std::packaged_task< GetDeploymentStrategyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetDeploymentStrategy(request); } );
646 auto packagedFunction = [task]() { (*task)(); };
647 m_executor->Submit(packagedFunction);
648 return task->get_future();
649 }
650
GetDeploymentStrategyAsync(const GetDeploymentStrategyRequest & request,const GetDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const651 void AppConfigClient::GetDeploymentStrategyAsync(const GetDeploymentStrategyRequest& request, const GetDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
652 {
653 m_executor->Submit( [this, request, handler, context](){ this->GetDeploymentStrategyAsyncHelper( request, handler, context ); } );
654 }
655
GetDeploymentStrategyAsyncHelper(const GetDeploymentStrategyRequest & request,const GetDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const656 void AppConfigClient::GetDeploymentStrategyAsyncHelper(const GetDeploymentStrategyRequest& request, const GetDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
657 {
658 handler(this, request, GetDeploymentStrategy(request), context);
659 }
660
GetEnvironment(const GetEnvironmentRequest & request) const661 GetEnvironmentOutcome AppConfigClient::GetEnvironment(const GetEnvironmentRequest& request) const
662 {
663 if (!request.ApplicationIdHasBeenSet())
664 {
665 AWS_LOGSTREAM_ERROR("GetEnvironment", "Required field: ApplicationId, is not set");
666 return GetEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
667 }
668 if (!request.EnvironmentIdHasBeenSet())
669 {
670 AWS_LOGSTREAM_ERROR("GetEnvironment", "Required field: EnvironmentId, is not set");
671 return GetEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
672 }
673 Aws::Http::URI uri = m_uri;
674 uri.AddPathSegments("/applications/");
675 uri.AddPathSegment(request.GetApplicationId());
676 uri.AddPathSegments("/environments/");
677 uri.AddPathSegment(request.GetEnvironmentId());
678 return GetEnvironmentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
679 }
680
GetEnvironmentCallable(const GetEnvironmentRequest & request) const681 GetEnvironmentOutcomeCallable AppConfigClient::GetEnvironmentCallable(const GetEnvironmentRequest& request) const
682 {
683 auto task = Aws::MakeShared< std::packaged_task< GetEnvironmentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetEnvironment(request); } );
684 auto packagedFunction = [task]() { (*task)(); };
685 m_executor->Submit(packagedFunction);
686 return task->get_future();
687 }
688
GetEnvironmentAsync(const GetEnvironmentRequest & request,const GetEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const689 void AppConfigClient::GetEnvironmentAsync(const GetEnvironmentRequest& request, const GetEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
690 {
691 m_executor->Submit( [this, request, handler, context](){ this->GetEnvironmentAsyncHelper( request, handler, context ); } );
692 }
693
GetEnvironmentAsyncHelper(const GetEnvironmentRequest & request,const GetEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const694 void AppConfigClient::GetEnvironmentAsyncHelper(const GetEnvironmentRequest& request, const GetEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
695 {
696 handler(this, request, GetEnvironment(request), context);
697 }
698
GetHostedConfigurationVersion(const GetHostedConfigurationVersionRequest & request) const699 GetHostedConfigurationVersionOutcome AppConfigClient::GetHostedConfigurationVersion(const GetHostedConfigurationVersionRequest& request) const
700 {
701 if (!request.ApplicationIdHasBeenSet())
702 {
703 AWS_LOGSTREAM_ERROR("GetHostedConfigurationVersion", "Required field: ApplicationId, is not set");
704 return GetHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
705 }
706 if (!request.ConfigurationProfileIdHasBeenSet())
707 {
708 AWS_LOGSTREAM_ERROR("GetHostedConfigurationVersion", "Required field: ConfigurationProfileId, is not set");
709 return GetHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
710 }
711 if (!request.VersionNumberHasBeenSet())
712 {
713 AWS_LOGSTREAM_ERROR("GetHostedConfigurationVersion", "Required field: VersionNumber, is not set");
714 return GetHostedConfigurationVersionOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
715 }
716 Aws::Http::URI uri = m_uri;
717 uri.AddPathSegments("/applications/");
718 uri.AddPathSegment(request.GetApplicationId());
719 uri.AddPathSegments("/configurationprofiles/");
720 uri.AddPathSegment(request.GetConfigurationProfileId());
721 uri.AddPathSegments("/hostedconfigurationversions/");
722 uri.AddPathSegment(request.GetVersionNumber());
723 return GetHostedConfigurationVersionOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
724 }
725
GetHostedConfigurationVersionCallable(const GetHostedConfigurationVersionRequest & request) const726 GetHostedConfigurationVersionOutcomeCallable AppConfigClient::GetHostedConfigurationVersionCallable(const GetHostedConfigurationVersionRequest& request) const
727 {
728 auto task = Aws::MakeShared< std::packaged_task< GetHostedConfigurationVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetHostedConfigurationVersion(request); } );
729 auto packagedFunction = [task]() { (*task)(); };
730 m_executor->Submit(packagedFunction);
731 return task->get_future();
732 }
733
GetHostedConfigurationVersionAsync(const GetHostedConfigurationVersionRequest & request,const GetHostedConfigurationVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const734 void AppConfigClient::GetHostedConfigurationVersionAsync(const GetHostedConfigurationVersionRequest& request, const GetHostedConfigurationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
735 {
736 m_executor->Submit( [this, request, handler, context](){ this->GetHostedConfigurationVersionAsyncHelper( request, handler, context ); } );
737 }
738
GetHostedConfigurationVersionAsyncHelper(const GetHostedConfigurationVersionRequest & request,const GetHostedConfigurationVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const739 void AppConfigClient::GetHostedConfigurationVersionAsyncHelper(const GetHostedConfigurationVersionRequest& request, const GetHostedConfigurationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
740 {
741 handler(this, request, GetHostedConfigurationVersion(request), context);
742 }
743
ListApplications(const ListApplicationsRequest & request) const744 ListApplicationsOutcome AppConfigClient::ListApplications(const ListApplicationsRequest& request) const
745 {
746 Aws::Http::URI uri = m_uri;
747 uri.AddPathSegments("/applications");
748 return ListApplicationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
749 }
750
ListApplicationsCallable(const ListApplicationsRequest & request) const751 ListApplicationsOutcomeCallable AppConfigClient::ListApplicationsCallable(const ListApplicationsRequest& request) const
752 {
753 auto task = Aws::MakeShared< std::packaged_task< ListApplicationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListApplications(request); } );
754 auto packagedFunction = [task]() { (*task)(); };
755 m_executor->Submit(packagedFunction);
756 return task->get_future();
757 }
758
ListApplicationsAsync(const ListApplicationsRequest & request,const ListApplicationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const759 void AppConfigClient::ListApplicationsAsync(const ListApplicationsRequest& request, const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
760 {
761 m_executor->Submit( [this, request, handler, context](){ this->ListApplicationsAsyncHelper( request, handler, context ); } );
762 }
763
ListApplicationsAsyncHelper(const ListApplicationsRequest & request,const ListApplicationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const764 void AppConfigClient::ListApplicationsAsyncHelper(const ListApplicationsRequest& request, const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
765 {
766 handler(this, request, ListApplications(request), context);
767 }
768
ListConfigurationProfiles(const ListConfigurationProfilesRequest & request) const769 ListConfigurationProfilesOutcome AppConfigClient::ListConfigurationProfiles(const ListConfigurationProfilesRequest& request) const
770 {
771 if (!request.ApplicationIdHasBeenSet())
772 {
773 AWS_LOGSTREAM_ERROR("ListConfigurationProfiles", "Required field: ApplicationId, is not set");
774 return ListConfigurationProfilesOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
775 }
776 Aws::Http::URI uri = m_uri;
777 uri.AddPathSegments("/applications/");
778 uri.AddPathSegment(request.GetApplicationId());
779 uri.AddPathSegments("/configurationprofiles");
780 return ListConfigurationProfilesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
781 }
782
ListConfigurationProfilesCallable(const ListConfigurationProfilesRequest & request) const783 ListConfigurationProfilesOutcomeCallable AppConfigClient::ListConfigurationProfilesCallable(const ListConfigurationProfilesRequest& request) const
784 {
785 auto task = Aws::MakeShared< std::packaged_task< ListConfigurationProfilesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListConfigurationProfiles(request); } );
786 auto packagedFunction = [task]() { (*task)(); };
787 m_executor->Submit(packagedFunction);
788 return task->get_future();
789 }
790
ListConfigurationProfilesAsync(const ListConfigurationProfilesRequest & request,const ListConfigurationProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const791 void AppConfigClient::ListConfigurationProfilesAsync(const ListConfigurationProfilesRequest& request, const ListConfigurationProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
792 {
793 m_executor->Submit( [this, request, handler, context](){ this->ListConfigurationProfilesAsyncHelper( request, handler, context ); } );
794 }
795
ListConfigurationProfilesAsyncHelper(const ListConfigurationProfilesRequest & request,const ListConfigurationProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const796 void AppConfigClient::ListConfigurationProfilesAsyncHelper(const ListConfigurationProfilesRequest& request, const ListConfigurationProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
797 {
798 handler(this, request, ListConfigurationProfiles(request), context);
799 }
800
ListDeploymentStrategies(const ListDeploymentStrategiesRequest & request) const801 ListDeploymentStrategiesOutcome AppConfigClient::ListDeploymentStrategies(const ListDeploymentStrategiesRequest& request) const
802 {
803 Aws::Http::URI uri = m_uri;
804 uri.AddPathSegments("/deploymentstrategies");
805 return ListDeploymentStrategiesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
806 }
807
ListDeploymentStrategiesCallable(const ListDeploymentStrategiesRequest & request) const808 ListDeploymentStrategiesOutcomeCallable AppConfigClient::ListDeploymentStrategiesCallable(const ListDeploymentStrategiesRequest& request) const
809 {
810 auto task = Aws::MakeShared< std::packaged_task< ListDeploymentStrategiesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDeploymentStrategies(request); } );
811 auto packagedFunction = [task]() { (*task)(); };
812 m_executor->Submit(packagedFunction);
813 return task->get_future();
814 }
815
ListDeploymentStrategiesAsync(const ListDeploymentStrategiesRequest & request,const ListDeploymentStrategiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const816 void AppConfigClient::ListDeploymentStrategiesAsync(const ListDeploymentStrategiesRequest& request, const ListDeploymentStrategiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
817 {
818 m_executor->Submit( [this, request, handler, context](){ this->ListDeploymentStrategiesAsyncHelper( request, handler, context ); } );
819 }
820
ListDeploymentStrategiesAsyncHelper(const ListDeploymentStrategiesRequest & request,const ListDeploymentStrategiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const821 void AppConfigClient::ListDeploymentStrategiesAsyncHelper(const ListDeploymentStrategiesRequest& request, const ListDeploymentStrategiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
822 {
823 handler(this, request, ListDeploymentStrategies(request), context);
824 }
825
ListDeployments(const ListDeploymentsRequest & request) const826 ListDeploymentsOutcome AppConfigClient::ListDeployments(const ListDeploymentsRequest& request) const
827 {
828 if (!request.ApplicationIdHasBeenSet())
829 {
830 AWS_LOGSTREAM_ERROR("ListDeployments", "Required field: ApplicationId, is not set");
831 return ListDeploymentsOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
832 }
833 if (!request.EnvironmentIdHasBeenSet())
834 {
835 AWS_LOGSTREAM_ERROR("ListDeployments", "Required field: EnvironmentId, is not set");
836 return ListDeploymentsOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
837 }
838 Aws::Http::URI uri = m_uri;
839 uri.AddPathSegments("/applications/");
840 uri.AddPathSegment(request.GetApplicationId());
841 uri.AddPathSegments("/environments/");
842 uri.AddPathSegment(request.GetEnvironmentId());
843 uri.AddPathSegments("/deployments");
844 return ListDeploymentsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
845 }
846
ListDeploymentsCallable(const ListDeploymentsRequest & request) const847 ListDeploymentsOutcomeCallable AppConfigClient::ListDeploymentsCallable(const ListDeploymentsRequest& request) const
848 {
849 auto task = Aws::MakeShared< std::packaged_task< ListDeploymentsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDeployments(request); } );
850 auto packagedFunction = [task]() { (*task)(); };
851 m_executor->Submit(packagedFunction);
852 return task->get_future();
853 }
854
ListDeploymentsAsync(const ListDeploymentsRequest & request,const ListDeploymentsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const855 void AppConfigClient::ListDeploymentsAsync(const ListDeploymentsRequest& request, const ListDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
856 {
857 m_executor->Submit( [this, request, handler, context](){ this->ListDeploymentsAsyncHelper( request, handler, context ); } );
858 }
859
ListDeploymentsAsyncHelper(const ListDeploymentsRequest & request,const ListDeploymentsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const860 void AppConfigClient::ListDeploymentsAsyncHelper(const ListDeploymentsRequest& request, const ListDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
861 {
862 handler(this, request, ListDeployments(request), context);
863 }
864
ListEnvironments(const ListEnvironmentsRequest & request) const865 ListEnvironmentsOutcome AppConfigClient::ListEnvironments(const ListEnvironmentsRequest& request) const
866 {
867 if (!request.ApplicationIdHasBeenSet())
868 {
869 AWS_LOGSTREAM_ERROR("ListEnvironments", "Required field: ApplicationId, is not set");
870 return ListEnvironmentsOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
871 }
872 Aws::Http::URI uri = m_uri;
873 uri.AddPathSegments("/applications/");
874 uri.AddPathSegment(request.GetApplicationId());
875 uri.AddPathSegments("/environments");
876 return ListEnvironmentsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
877 }
878
ListEnvironmentsCallable(const ListEnvironmentsRequest & request) const879 ListEnvironmentsOutcomeCallable AppConfigClient::ListEnvironmentsCallable(const ListEnvironmentsRequest& request) const
880 {
881 auto task = Aws::MakeShared< std::packaged_task< ListEnvironmentsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEnvironments(request); } );
882 auto packagedFunction = [task]() { (*task)(); };
883 m_executor->Submit(packagedFunction);
884 return task->get_future();
885 }
886
ListEnvironmentsAsync(const ListEnvironmentsRequest & request,const ListEnvironmentsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const887 void AppConfigClient::ListEnvironmentsAsync(const ListEnvironmentsRequest& request, const ListEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
888 {
889 m_executor->Submit( [this, request, handler, context](){ this->ListEnvironmentsAsyncHelper( request, handler, context ); } );
890 }
891
ListEnvironmentsAsyncHelper(const ListEnvironmentsRequest & request,const ListEnvironmentsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const892 void AppConfigClient::ListEnvironmentsAsyncHelper(const ListEnvironmentsRequest& request, const ListEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
893 {
894 handler(this, request, ListEnvironments(request), context);
895 }
896
ListHostedConfigurationVersions(const ListHostedConfigurationVersionsRequest & request) const897 ListHostedConfigurationVersionsOutcome AppConfigClient::ListHostedConfigurationVersions(const ListHostedConfigurationVersionsRequest& request) const
898 {
899 if (!request.ApplicationIdHasBeenSet())
900 {
901 AWS_LOGSTREAM_ERROR("ListHostedConfigurationVersions", "Required field: ApplicationId, is not set");
902 return ListHostedConfigurationVersionsOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
903 }
904 if (!request.ConfigurationProfileIdHasBeenSet())
905 {
906 AWS_LOGSTREAM_ERROR("ListHostedConfigurationVersions", "Required field: ConfigurationProfileId, is not set");
907 return ListHostedConfigurationVersionsOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
908 }
909 Aws::Http::URI uri = m_uri;
910 uri.AddPathSegments("/applications/");
911 uri.AddPathSegment(request.GetApplicationId());
912 uri.AddPathSegments("/configurationprofiles/");
913 uri.AddPathSegment(request.GetConfigurationProfileId());
914 uri.AddPathSegments("/hostedconfigurationversions");
915 return ListHostedConfigurationVersionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
916 }
917
ListHostedConfigurationVersionsCallable(const ListHostedConfigurationVersionsRequest & request) const918 ListHostedConfigurationVersionsOutcomeCallable AppConfigClient::ListHostedConfigurationVersionsCallable(const ListHostedConfigurationVersionsRequest& request) const
919 {
920 auto task = Aws::MakeShared< std::packaged_task< ListHostedConfigurationVersionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListHostedConfigurationVersions(request); } );
921 auto packagedFunction = [task]() { (*task)(); };
922 m_executor->Submit(packagedFunction);
923 return task->get_future();
924 }
925
ListHostedConfigurationVersionsAsync(const ListHostedConfigurationVersionsRequest & request,const ListHostedConfigurationVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const926 void AppConfigClient::ListHostedConfigurationVersionsAsync(const ListHostedConfigurationVersionsRequest& request, const ListHostedConfigurationVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
927 {
928 m_executor->Submit( [this, request, handler, context](){ this->ListHostedConfigurationVersionsAsyncHelper( request, handler, context ); } );
929 }
930
ListHostedConfigurationVersionsAsyncHelper(const ListHostedConfigurationVersionsRequest & request,const ListHostedConfigurationVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const931 void AppConfigClient::ListHostedConfigurationVersionsAsyncHelper(const ListHostedConfigurationVersionsRequest& request, const ListHostedConfigurationVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
932 {
933 handler(this, request, ListHostedConfigurationVersions(request), context);
934 }
935
ListTagsForResource(const ListTagsForResourceRequest & request) const936 ListTagsForResourceOutcome AppConfigClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
937 {
938 if (!request.ResourceArnHasBeenSet())
939 {
940 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
941 return ListTagsForResourceOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
942 }
943 Aws::Http::URI uri = m_uri;
944 uri.AddPathSegments("/tags/");
945 uri.AddPathSegment(request.GetResourceArn());
946 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
947 }
948
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const949 ListTagsForResourceOutcomeCallable AppConfigClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
950 {
951 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
952 auto packagedFunction = [task]() { (*task)(); };
953 m_executor->Submit(packagedFunction);
954 return task->get_future();
955 }
956
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const957 void AppConfigClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
958 {
959 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
960 }
961
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const962 void AppConfigClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
963 {
964 handler(this, request, ListTagsForResource(request), context);
965 }
966
StartDeployment(const StartDeploymentRequest & request) const967 StartDeploymentOutcome AppConfigClient::StartDeployment(const StartDeploymentRequest& request) const
968 {
969 if (!request.ApplicationIdHasBeenSet())
970 {
971 AWS_LOGSTREAM_ERROR("StartDeployment", "Required field: ApplicationId, is not set");
972 return StartDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
973 }
974 if (!request.EnvironmentIdHasBeenSet())
975 {
976 AWS_LOGSTREAM_ERROR("StartDeployment", "Required field: EnvironmentId, is not set");
977 return StartDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
978 }
979 Aws::Http::URI uri = m_uri;
980 uri.AddPathSegments("/applications/");
981 uri.AddPathSegment(request.GetApplicationId());
982 uri.AddPathSegments("/environments/");
983 uri.AddPathSegment(request.GetEnvironmentId());
984 uri.AddPathSegments("/deployments");
985 return StartDeploymentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
986 }
987
StartDeploymentCallable(const StartDeploymentRequest & request) const988 StartDeploymentOutcomeCallable AppConfigClient::StartDeploymentCallable(const StartDeploymentRequest& request) const
989 {
990 auto task = Aws::MakeShared< std::packaged_task< StartDeploymentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartDeployment(request); } );
991 auto packagedFunction = [task]() { (*task)(); };
992 m_executor->Submit(packagedFunction);
993 return task->get_future();
994 }
995
StartDeploymentAsync(const StartDeploymentRequest & request,const StartDeploymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const996 void AppConfigClient::StartDeploymentAsync(const StartDeploymentRequest& request, const StartDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
997 {
998 m_executor->Submit( [this, request, handler, context](){ this->StartDeploymentAsyncHelper( request, handler, context ); } );
999 }
1000
StartDeploymentAsyncHelper(const StartDeploymentRequest & request,const StartDeploymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1001 void AppConfigClient::StartDeploymentAsyncHelper(const StartDeploymentRequest& request, const StartDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1002 {
1003 handler(this, request, StartDeployment(request), context);
1004 }
1005
StopDeployment(const StopDeploymentRequest & request) const1006 StopDeploymentOutcome AppConfigClient::StopDeployment(const StopDeploymentRequest& request) const
1007 {
1008 if (!request.ApplicationIdHasBeenSet())
1009 {
1010 AWS_LOGSTREAM_ERROR("StopDeployment", "Required field: ApplicationId, is not set");
1011 return StopDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
1012 }
1013 if (!request.EnvironmentIdHasBeenSet())
1014 {
1015 AWS_LOGSTREAM_ERROR("StopDeployment", "Required field: EnvironmentId, is not set");
1016 return StopDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
1017 }
1018 if (!request.DeploymentNumberHasBeenSet())
1019 {
1020 AWS_LOGSTREAM_ERROR("StopDeployment", "Required field: DeploymentNumber, is not set");
1021 return StopDeploymentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeploymentNumber]", false));
1022 }
1023 Aws::Http::URI uri = m_uri;
1024 uri.AddPathSegments("/applications/");
1025 uri.AddPathSegment(request.GetApplicationId());
1026 uri.AddPathSegments("/environments/");
1027 uri.AddPathSegment(request.GetEnvironmentId());
1028 uri.AddPathSegments("/deployments/");
1029 uri.AddPathSegment(request.GetDeploymentNumber());
1030 return StopDeploymentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1031 }
1032
StopDeploymentCallable(const StopDeploymentRequest & request) const1033 StopDeploymentOutcomeCallable AppConfigClient::StopDeploymentCallable(const StopDeploymentRequest& request) const
1034 {
1035 auto task = Aws::MakeShared< std::packaged_task< StopDeploymentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopDeployment(request); } );
1036 auto packagedFunction = [task]() { (*task)(); };
1037 m_executor->Submit(packagedFunction);
1038 return task->get_future();
1039 }
1040
StopDeploymentAsync(const StopDeploymentRequest & request,const StopDeploymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1041 void AppConfigClient::StopDeploymentAsync(const StopDeploymentRequest& request, const StopDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1042 {
1043 m_executor->Submit( [this, request, handler, context](){ this->StopDeploymentAsyncHelper( request, handler, context ); } );
1044 }
1045
StopDeploymentAsyncHelper(const StopDeploymentRequest & request,const StopDeploymentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1046 void AppConfigClient::StopDeploymentAsyncHelper(const StopDeploymentRequest& request, const StopDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1047 {
1048 handler(this, request, StopDeployment(request), context);
1049 }
1050
TagResource(const TagResourceRequest & request) const1051 TagResourceOutcome AppConfigClient::TagResource(const TagResourceRequest& request) const
1052 {
1053 if (!request.ResourceArnHasBeenSet())
1054 {
1055 AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
1056 return TagResourceOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1057 }
1058 Aws::Http::URI uri = m_uri;
1059 uri.AddPathSegments("/tags/");
1060 uri.AddPathSegment(request.GetResourceArn());
1061 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1062 }
1063
TagResourceCallable(const TagResourceRequest & request) const1064 TagResourceOutcomeCallable AppConfigClient::TagResourceCallable(const TagResourceRequest& request) const
1065 {
1066 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1067 auto packagedFunction = [task]() { (*task)(); };
1068 m_executor->Submit(packagedFunction);
1069 return task->get_future();
1070 }
1071
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1072 void AppConfigClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1073 {
1074 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1075 }
1076
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1077 void AppConfigClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1078 {
1079 handler(this, request, TagResource(request), context);
1080 }
1081
UntagResource(const UntagResourceRequest & request) const1082 UntagResourceOutcome AppConfigClient::UntagResource(const UntagResourceRequest& request) const
1083 {
1084 if (!request.ResourceArnHasBeenSet())
1085 {
1086 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
1087 return UntagResourceOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1088 }
1089 if (!request.TagKeysHasBeenSet())
1090 {
1091 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
1092 return UntagResourceOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
1093 }
1094 Aws::Http::URI uri = m_uri;
1095 uri.AddPathSegments("/tags/");
1096 uri.AddPathSegment(request.GetResourceArn());
1097 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1098 }
1099
UntagResourceCallable(const UntagResourceRequest & request) const1100 UntagResourceOutcomeCallable AppConfigClient::UntagResourceCallable(const UntagResourceRequest& request) const
1101 {
1102 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1103 auto packagedFunction = [task]() { (*task)(); };
1104 m_executor->Submit(packagedFunction);
1105 return task->get_future();
1106 }
1107
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1108 void AppConfigClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1109 {
1110 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1111 }
1112
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1113 void AppConfigClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1114 {
1115 handler(this, request, UntagResource(request), context);
1116 }
1117
UpdateApplication(const UpdateApplicationRequest & request) const1118 UpdateApplicationOutcome AppConfigClient::UpdateApplication(const UpdateApplicationRequest& request) const
1119 {
1120 if (!request.ApplicationIdHasBeenSet())
1121 {
1122 AWS_LOGSTREAM_ERROR("UpdateApplication", "Required field: ApplicationId, is not set");
1123 return UpdateApplicationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
1124 }
1125 Aws::Http::URI uri = m_uri;
1126 uri.AddPathSegments("/applications/");
1127 uri.AddPathSegment(request.GetApplicationId());
1128 return UpdateApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
1129 }
1130
UpdateApplicationCallable(const UpdateApplicationRequest & request) const1131 UpdateApplicationOutcomeCallable AppConfigClient::UpdateApplicationCallable(const UpdateApplicationRequest& request) const
1132 {
1133 auto task = Aws::MakeShared< std::packaged_task< UpdateApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateApplication(request); } );
1134 auto packagedFunction = [task]() { (*task)(); };
1135 m_executor->Submit(packagedFunction);
1136 return task->get_future();
1137 }
1138
UpdateApplicationAsync(const UpdateApplicationRequest & request,const UpdateApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1139 void AppConfigClient::UpdateApplicationAsync(const UpdateApplicationRequest& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1140 {
1141 m_executor->Submit( [this, request, handler, context](){ this->UpdateApplicationAsyncHelper( request, handler, context ); } );
1142 }
1143
UpdateApplicationAsyncHelper(const UpdateApplicationRequest & request,const UpdateApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1144 void AppConfigClient::UpdateApplicationAsyncHelper(const UpdateApplicationRequest& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1145 {
1146 handler(this, request, UpdateApplication(request), context);
1147 }
1148
UpdateConfigurationProfile(const UpdateConfigurationProfileRequest & request) const1149 UpdateConfigurationProfileOutcome AppConfigClient::UpdateConfigurationProfile(const UpdateConfigurationProfileRequest& request) const
1150 {
1151 if (!request.ApplicationIdHasBeenSet())
1152 {
1153 AWS_LOGSTREAM_ERROR("UpdateConfigurationProfile", "Required field: ApplicationId, is not set");
1154 return UpdateConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
1155 }
1156 if (!request.ConfigurationProfileIdHasBeenSet())
1157 {
1158 AWS_LOGSTREAM_ERROR("UpdateConfigurationProfile", "Required field: ConfigurationProfileId, is not set");
1159 return UpdateConfigurationProfileOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
1160 }
1161 Aws::Http::URI uri = m_uri;
1162 uri.AddPathSegments("/applications/");
1163 uri.AddPathSegment(request.GetApplicationId());
1164 uri.AddPathSegments("/configurationprofiles/");
1165 uri.AddPathSegment(request.GetConfigurationProfileId());
1166 return UpdateConfigurationProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
1167 }
1168
UpdateConfigurationProfileCallable(const UpdateConfigurationProfileRequest & request) const1169 UpdateConfigurationProfileOutcomeCallable AppConfigClient::UpdateConfigurationProfileCallable(const UpdateConfigurationProfileRequest& request) const
1170 {
1171 auto task = Aws::MakeShared< std::packaged_task< UpdateConfigurationProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateConfigurationProfile(request); } );
1172 auto packagedFunction = [task]() { (*task)(); };
1173 m_executor->Submit(packagedFunction);
1174 return task->get_future();
1175 }
1176
UpdateConfigurationProfileAsync(const UpdateConfigurationProfileRequest & request,const UpdateConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1177 void AppConfigClient::UpdateConfigurationProfileAsync(const UpdateConfigurationProfileRequest& request, const UpdateConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1178 {
1179 m_executor->Submit( [this, request, handler, context](){ this->UpdateConfigurationProfileAsyncHelper( request, handler, context ); } );
1180 }
1181
UpdateConfigurationProfileAsyncHelper(const UpdateConfigurationProfileRequest & request,const UpdateConfigurationProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1182 void AppConfigClient::UpdateConfigurationProfileAsyncHelper(const UpdateConfigurationProfileRequest& request, const UpdateConfigurationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1183 {
1184 handler(this, request, UpdateConfigurationProfile(request), context);
1185 }
1186
UpdateDeploymentStrategy(const UpdateDeploymentStrategyRequest & request) const1187 UpdateDeploymentStrategyOutcome AppConfigClient::UpdateDeploymentStrategy(const UpdateDeploymentStrategyRequest& request) const
1188 {
1189 if (!request.DeploymentStrategyIdHasBeenSet())
1190 {
1191 AWS_LOGSTREAM_ERROR("UpdateDeploymentStrategy", "Required field: DeploymentStrategyId, is not set");
1192 return UpdateDeploymentStrategyOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeploymentStrategyId]", false));
1193 }
1194 Aws::Http::URI uri = m_uri;
1195 uri.AddPathSegments("/deploymentstrategies/");
1196 uri.AddPathSegment(request.GetDeploymentStrategyId());
1197 return UpdateDeploymentStrategyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
1198 }
1199
UpdateDeploymentStrategyCallable(const UpdateDeploymentStrategyRequest & request) const1200 UpdateDeploymentStrategyOutcomeCallable AppConfigClient::UpdateDeploymentStrategyCallable(const UpdateDeploymentStrategyRequest& request) const
1201 {
1202 auto task = Aws::MakeShared< std::packaged_task< UpdateDeploymentStrategyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateDeploymentStrategy(request); } );
1203 auto packagedFunction = [task]() { (*task)(); };
1204 m_executor->Submit(packagedFunction);
1205 return task->get_future();
1206 }
1207
UpdateDeploymentStrategyAsync(const UpdateDeploymentStrategyRequest & request,const UpdateDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1208 void AppConfigClient::UpdateDeploymentStrategyAsync(const UpdateDeploymentStrategyRequest& request, const UpdateDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1209 {
1210 m_executor->Submit( [this, request, handler, context](){ this->UpdateDeploymentStrategyAsyncHelper( request, handler, context ); } );
1211 }
1212
UpdateDeploymentStrategyAsyncHelper(const UpdateDeploymentStrategyRequest & request,const UpdateDeploymentStrategyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1213 void AppConfigClient::UpdateDeploymentStrategyAsyncHelper(const UpdateDeploymentStrategyRequest& request, const UpdateDeploymentStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1214 {
1215 handler(this, request, UpdateDeploymentStrategy(request), context);
1216 }
1217
UpdateEnvironment(const UpdateEnvironmentRequest & request) const1218 UpdateEnvironmentOutcome AppConfigClient::UpdateEnvironment(const UpdateEnvironmentRequest& request) const
1219 {
1220 if (!request.ApplicationIdHasBeenSet())
1221 {
1222 AWS_LOGSTREAM_ERROR("UpdateEnvironment", "Required field: ApplicationId, is not set");
1223 return UpdateEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
1224 }
1225 if (!request.EnvironmentIdHasBeenSet())
1226 {
1227 AWS_LOGSTREAM_ERROR("UpdateEnvironment", "Required field: EnvironmentId, is not set");
1228 return UpdateEnvironmentOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [EnvironmentId]", false));
1229 }
1230 Aws::Http::URI uri = m_uri;
1231 uri.AddPathSegments("/applications/");
1232 uri.AddPathSegment(request.GetApplicationId());
1233 uri.AddPathSegments("/environments/");
1234 uri.AddPathSegment(request.GetEnvironmentId());
1235 return UpdateEnvironmentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
1236 }
1237
UpdateEnvironmentCallable(const UpdateEnvironmentRequest & request) const1238 UpdateEnvironmentOutcomeCallable AppConfigClient::UpdateEnvironmentCallable(const UpdateEnvironmentRequest& request) const
1239 {
1240 auto task = Aws::MakeShared< std::packaged_task< UpdateEnvironmentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateEnvironment(request); } );
1241 auto packagedFunction = [task]() { (*task)(); };
1242 m_executor->Submit(packagedFunction);
1243 return task->get_future();
1244 }
1245
UpdateEnvironmentAsync(const UpdateEnvironmentRequest & request,const UpdateEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1246 void AppConfigClient::UpdateEnvironmentAsync(const UpdateEnvironmentRequest& request, const UpdateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1247 {
1248 m_executor->Submit( [this, request, handler, context](){ this->UpdateEnvironmentAsyncHelper( request, handler, context ); } );
1249 }
1250
UpdateEnvironmentAsyncHelper(const UpdateEnvironmentRequest & request,const UpdateEnvironmentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1251 void AppConfigClient::UpdateEnvironmentAsyncHelper(const UpdateEnvironmentRequest& request, const UpdateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1252 {
1253 handler(this, request, UpdateEnvironment(request), context);
1254 }
1255
ValidateConfiguration(const ValidateConfigurationRequest & request) const1256 ValidateConfigurationOutcome AppConfigClient::ValidateConfiguration(const ValidateConfigurationRequest& request) const
1257 {
1258 if (!request.ApplicationIdHasBeenSet())
1259 {
1260 AWS_LOGSTREAM_ERROR("ValidateConfiguration", "Required field: ApplicationId, is not set");
1261 return ValidateConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApplicationId]", false));
1262 }
1263 if (!request.ConfigurationProfileIdHasBeenSet())
1264 {
1265 AWS_LOGSTREAM_ERROR("ValidateConfiguration", "Required field: ConfigurationProfileId, is not set");
1266 return ValidateConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationProfileId]", false));
1267 }
1268 if (!request.ConfigurationVersionHasBeenSet())
1269 {
1270 AWS_LOGSTREAM_ERROR("ValidateConfiguration", "Required field: ConfigurationVersion, is not set");
1271 return ValidateConfigurationOutcome(Aws::Client::AWSError<AppConfigErrors>(AppConfigErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConfigurationVersion]", false));
1272 }
1273 Aws::Http::URI uri = m_uri;
1274 uri.AddPathSegments("/applications/");
1275 uri.AddPathSegment(request.GetApplicationId());
1276 uri.AddPathSegments("/configurationprofiles/");
1277 uri.AddPathSegment(request.GetConfigurationProfileId());
1278 uri.AddPathSegments("/validators");
1279 return ValidateConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1280 }
1281
ValidateConfigurationCallable(const ValidateConfigurationRequest & request) const1282 ValidateConfigurationOutcomeCallable AppConfigClient::ValidateConfigurationCallable(const ValidateConfigurationRequest& request) const
1283 {
1284 auto task = Aws::MakeShared< std::packaged_task< ValidateConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ValidateConfiguration(request); } );
1285 auto packagedFunction = [task]() { (*task)(); };
1286 m_executor->Submit(packagedFunction);
1287 return task->get_future();
1288 }
1289
ValidateConfigurationAsync(const ValidateConfigurationRequest & request,const ValidateConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1290 void AppConfigClient::ValidateConfigurationAsync(const ValidateConfigurationRequest& request, const ValidateConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1291 {
1292 m_executor->Submit( [this, request, handler, context](){ this->ValidateConfigurationAsyncHelper( request, handler, context ); } );
1293 }
1294
ValidateConfigurationAsyncHelper(const ValidateConfigurationRequest & request,const ValidateConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1295 void AppConfigClient::ValidateConfigurationAsyncHelper(const ValidateConfigurationRequest& request, const ValidateConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1296 {
1297 handler(this, request, ValidateConfiguration(request), context);
1298 }
1299
1300