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/snow-device-management/SnowDeviceManagementClient.h>
21 #include <aws/snow-device-management/SnowDeviceManagementEndpoint.h>
22 #include <aws/snow-device-management/SnowDeviceManagementErrorMarshaller.h>
23 #include <aws/snow-device-management/model/CancelTaskRequest.h>
24 #include <aws/snow-device-management/model/CreateTaskRequest.h>
25 #include <aws/snow-device-management/model/DescribeDeviceRequest.h>
26 #include <aws/snow-device-management/model/DescribeDeviceEc2InstancesRequest.h>
27 #include <aws/snow-device-management/model/DescribeExecutionRequest.h>
28 #include <aws/snow-device-management/model/DescribeTaskRequest.h>
29 #include <aws/snow-device-management/model/ListDeviceResourcesRequest.h>
30 #include <aws/snow-device-management/model/ListDevicesRequest.h>
31 #include <aws/snow-device-management/model/ListExecutionsRequest.h>
32 #include <aws/snow-device-management/model/ListTagsForResourceRequest.h>
33 #include <aws/snow-device-management/model/ListTasksRequest.h>
34 #include <aws/snow-device-management/model/TagResourceRequest.h>
35 #include <aws/snow-device-management/model/UntagResourceRequest.h>
36
37 using namespace Aws;
38 using namespace Aws::Auth;
39 using namespace Aws::Client;
40 using namespace Aws::SnowDeviceManagement;
41 using namespace Aws::SnowDeviceManagement::Model;
42 using namespace Aws::Http;
43 using namespace Aws::Utils::Json;
44
45 static const char* SERVICE_NAME = "snow-device-management";
46 static const char* ALLOCATION_TAG = "SnowDeviceManagementClient";
47
48
SnowDeviceManagementClient(const Client::ClientConfiguration & clientConfiguration)49 SnowDeviceManagementClient::SnowDeviceManagementClient(const Client::ClientConfiguration& clientConfiguration) :
50 BASECLASS(clientConfiguration,
51 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
52 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
53 Aws::MakeShared<SnowDeviceManagementErrorMarshaller>(ALLOCATION_TAG)),
54 m_executor(clientConfiguration.executor)
55 {
56 init(clientConfiguration);
57 }
58
SnowDeviceManagementClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)59 SnowDeviceManagementClient::SnowDeviceManagementClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
60 BASECLASS(clientConfiguration,
61 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
62 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
63 Aws::MakeShared<SnowDeviceManagementErrorMarshaller>(ALLOCATION_TAG)),
64 m_executor(clientConfiguration.executor)
65 {
66 init(clientConfiguration);
67 }
68
SnowDeviceManagementClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)69 SnowDeviceManagementClient::SnowDeviceManagementClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
70 const Client::ClientConfiguration& clientConfiguration) :
71 BASECLASS(clientConfiguration,
72 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
73 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
74 Aws::MakeShared<SnowDeviceManagementErrorMarshaller>(ALLOCATION_TAG)),
75 m_executor(clientConfiguration.executor)
76 {
77 init(clientConfiguration);
78 }
79
~SnowDeviceManagementClient()80 SnowDeviceManagementClient::~SnowDeviceManagementClient()
81 {
82 }
83
init(const Client::ClientConfiguration & config)84 void SnowDeviceManagementClient::init(const Client::ClientConfiguration& config)
85 {
86 SetServiceClientName("Snow Device Management");
87 m_configScheme = SchemeMapper::ToString(config.scheme);
88 if (config.endpointOverride.empty())
89 {
90 m_uri = m_configScheme + "://" + SnowDeviceManagementEndpoint::ForRegion(config.region, config.useDualStack);
91 }
92 else
93 {
94 OverrideEndpoint(config.endpointOverride);
95 }
96 }
97
OverrideEndpoint(const Aws::String & endpoint)98 void SnowDeviceManagementClient::OverrideEndpoint(const Aws::String& endpoint)
99 {
100 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
101 {
102 m_uri = endpoint;
103 }
104 else
105 {
106 m_uri = m_configScheme + "://" + endpoint;
107 }
108 }
109
CancelTask(const CancelTaskRequest & request) const110 CancelTaskOutcome SnowDeviceManagementClient::CancelTask(const CancelTaskRequest& request) const
111 {
112 if (!request.TaskIdHasBeenSet())
113 {
114 AWS_LOGSTREAM_ERROR("CancelTask", "Required field: TaskId, is not set");
115 return CancelTaskOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TaskId]", false));
116 }
117 Aws::Http::URI uri = m_uri;
118 uri.AddPathSegments("/task/");
119 uri.AddPathSegment(request.GetTaskId());
120 uri.AddPathSegments("/cancel");
121 return CancelTaskOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
122 }
123
CancelTaskCallable(const CancelTaskRequest & request) const124 CancelTaskOutcomeCallable SnowDeviceManagementClient::CancelTaskCallable(const CancelTaskRequest& request) const
125 {
126 auto task = Aws::MakeShared< std::packaged_task< CancelTaskOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CancelTask(request); } );
127 auto packagedFunction = [task]() { (*task)(); };
128 m_executor->Submit(packagedFunction);
129 return task->get_future();
130 }
131
CancelTaskAsync(const CancelTaskRequest & request,const CancelTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const132 void SnowDeviceManagementClient::CancelTaskAsync(const CancelTaskRequest& request, const CancelTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
133 {
134 m_executor->Submit( [this, request, handler, context](){ this->CancelTaskAsyncHelper( request, handler, context ); } );
135 }
136
CancelTaskAsyncHelper(const CancelTaskRequest & request,const CancelTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const137 void SnowDeviceManagementClient::CancelTaskAsyncHelper(const CancelTaskRequest& request, const CancelTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
138 {
139 handler(this, request, CancelTask(request), context);
140 }
141
CreateTask(const CreateTaskRequest & request) const142 CreateTaskOutcome SnowDeviceManagementClient::CreateTask(const CreateTaskRequest& request) const
143 {
144 Aws::Http::URI uri = m_uri;
145 uri.AddPathSegments("/task");
146 return CreateTaskOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
147 }
148
CreateTaskCallable(const CreateTaskRequest & request) const149 CreateTaskOutcomeCallable SnowDeviceManagementClient::CreateTaskCallable(const CreateTaskRequest& request) const
150 {
151 auto task = Aws::MakeShared< std::packaged_task< CreateTaskOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateTask(request); } );
152 auto packagedFunction = [task]() { (*task)(); };
153 m_executor->Submit(packagedFunction);
154 return task->get_future();
155 }
156
CreateTaskAsync(const CreateTaskRequest & request,const CreateTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const157 void SnowDeviceManagementClient::CreateTaskAsync(const CreateTaskRequest& request, const CreateTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
158 {
159 m_executor->Submit( [this, request, handler, context](){ this->CreateTaskAsyncHelper( request, handler, context ); } );
160 }
161
CreateTaskAsyncHelper(const CreateTaskRequest & request,const CreateTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const162 void SnowDeviceManagementClient::CreateTaskAsyncHelper(const CreateTaskRequest& request, const CreateTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
163 {
164 handler(this, request, CreateTask(request), context);
165 }
166
DescribeDevice(const DescribeDeviceRequest & request) const167 DescribeDeviceOutcome SnowDeviceManagementClient::DescribeDevice(const DescribeDeviceRequest& request) const
168 {
169 if (!request.ManagedDeviceIdHasBeenSet())
170 {
171 AWS_LOGSTREAM_ERROR("DescribeDevice", "Required field: ManagedDeviceId, is not set");
172 return DescribeDeviceOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ManagedDeviceId]", false));
173 }
174 Aws::Http::URI uri = m_uri;
175 uri.AddPathSegments("/managed-device/");
176 uri.AddPathSegment(request.GetManagedDeviceId());
177 uri.AddPathSegments("/describe");
178 return DescribeDeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
179 }
180
DescribeDeviceCallable(const DescribeDeviceRequest & request) const181 DescribeDeviceOutcomeCallable SnowDeviceManagementClient::DescribeDeviceCallable(const DescribeDeviceRequest& request) const
182 {
183 auto task = Aws::MakeShared< std::packaged_task< DescribeDeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDevice(request); } );
184 auto packagedFunction = [task]() { (*task)(); };
185 m_executor->Submit(packagedFunction);
186 return task->get_future();
187 }
188
DescribeDeviceAsync(const DescribeDeviceRequest & request,const DescribeDeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const189 void SnowDeviceManagementClient::DescribeDeviceAsync(const DescribeDeviceRequest& request, const DescribeDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
190 {
191 m_executor->Submit( [this, request, handler, context](){ this->DescribeDeviceAsyncHelper( request, handler, context ); } );
192 }
193
DescribeDeviceAsyncHelper(const DescribeDeviceRequest & request,const DescribeDeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const194 void SnowDeviceManagementClient::DescribeDeviceAsyncHelper(const DescribeDeviceRequest& request, const DescribeDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
195 {
196 handler(this, request, DescribeDevice(request), context);
197 }
198
DescribeDeviceEc2Instances(const DescribeDeviceEc2InstancesRequest & request) const199 DescribeDeviceEc2InstancesOutcome SnowDeviceManagementClient::DescribeDeviceEc2Instances(const DescribeDeviceEc2InstancesRequest& request) const
200 {
201 if (!request.ManagedDeviceIdHasBeenSet())
202 {
203 AWS_LOGSTREAM_ERROR("DescribeDeviceEc2Instances", "Required field: ManagedDeviceId, is not set");
204 return DescribeDeviceEc2InstancesOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ManagedDeviceId]", false));
205 }
206 Aws::Http::URI uri = m_uri;
207 uri.AddPathSegments("/managed-device/");
208 uri.AddPathSegment(request.GetManagedDeviceId());
209 uri.AddPathSegments("/resources/ec2/describe");
210 return DescribeDeviceEc2InstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
211 }
212
DescribeDeviceEc2InstancesCallable(const DescribeDeviceEc2InstancesRequest & request) const213 DescribeDeviceEc2InstancesOutcomeCallable SnowDeviceManagementClient::DescribeDeviceEc2InstancesCallable(const DescribeDeviceEc2InstancesRequest& request) const
214 {
215 auto task = Aws::MakeShared< std::packaged_task< DescribeDeviceEc2InstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDeviceEc2Instances(request); } );
216 auto packagedFunction = [task]() { (*task)(); };
217 m_executor->Submit(packagedFunction);
218 return task->get_future();
219 }
220
DescribeDeviceEc2InstancesAsync(const DescribeDeviceEc2InstancesRequest & request,const DescribeDeviceEc2InstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const221 void SnowDeviceManagementClient::DescribeDeviceEc2InstancesAsync(const DescribeDeviceEc2InstancesRequest& request, const DescribeDeviceEc2InstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
222 {
223 m_executor->Submit( [this, request, handler, context](){ this->DescribeDeviceEc2InstancesAsyncHelper( request, handler, context ); } );
224 }
225
DescribeDeviceEc2InstancesAsyncHelper(const DescribeDeviceEc2InstancesRequest & request,const DescribeDeviceEc2InstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const226 void SnowDeviceManagementClient::DescribeDeviceEc2InstancesAsyncHelper(const DescribeDeviceEc2InstancesRequest& request, const DescribeDeviceEc2InstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
227 {
228 handler(this, request, DescribeDeviceEc2Instances(request), context);
229 }
230
DescribeExecution(const DescribeExecutionRequest & request) const231 DescribeExecutionOutcome SnowDeviceManagementClient::DescribeExecution(const DescribeExecutionRequest& request) const
232 {
233 if (!request.ManagedDeviceIdHasBeenSet())
234 {
235 AWS_LOGSTREAM_ERROR("DescribeExecution", "Required field: ManagedDeviceId, is not set");
236 return DescribeExecutionOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ManagedDeviceId]", false));
237 }
238 if (!request.TaskIdHasBeenSet())
239 {
240 AWS_LOGSTREAM_ERROR("DescribeExecution", "Required field: TaskId, is not set");
241 return DescribeExecutionOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TaskId]", false));
242 }
243 Aws::Http::URI uri = m_uri;
244 uri.AddPathSegments("/task/");
245 uri.AddPathSegment(request.GetTaskId());
246 uri.AddPathSegments("/execution/");
247 uri.AddPathSegment(request.GetManagedDeviceId());
248 return DescribeExecutionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
249 }
250
DescribeExecutionCallable(const DescribeExecutionRequest & request) const251 DescribeExecutionOutcomeCallable SnowDeviceManagementClient::DescribeExecutionCallable(const DescribeExecutionRequest& request) const
252 {
253 auto task = Aws::MakeShared< std::packaged_task< DescribeExecutionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeExecution(request); } );
254 auto packagedFunction = [task]() { (*task)(); };
255 m_executor->Submit(packagedFunction);
256 return task->get_future();
257 }
258
DescribeExecutionAsync(const DescribeExecutionRequest & request,const DescribeExecutionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const259 void SnowDeviceManagementClient::DescribeExecutionAsync(const DescribeExecutionRequest& request, const DescribeExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
260 {
261 m_executor->Submit( [this, request, handler, context](){ this->DescribeExecutionAsyncHelper( request, handler, context ); } );
262 }
263
DescribeExecutionAsyncHelper(const DescribeExecutionRequest & request,const DescribeExecutionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const264 void SnowDeviceManagementClient::DescribeExecutionAsyncHelper(const DescribeExecutionRequest& request, const DescribeExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
265 {
266 handler(this, request, DescribeExecution(request), context);
267 }
268
DescribeTask(const DescribeTaskRequest & request) const269 DescribeTaskOutcome SnowDeviceManagementClient::DescribeTask(const DescribeTaskRequest& request) const
270 {
271 if (!request.TaskIdHasBeenSet())
272 {
273 AWS_LOGSTREAM_ERROR("DescribeTask", "Required field: TaskId, is not set");
274 return DescribeTaskOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TaskId]", false));
275 }
276 Aws::Http::URI uri = m_uri;
277 uri.AddPathSegments("/task/");
278 uri.AddPathSegment(request.GetTaskId());
279 return DescribeTaskOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
280 }
281
DescribeTaskCallable(const DescribeTaskRequest & request) const282 DescribeTaskOutcomeCallable SnowDeviceManagementClient::DescribeTaskCallable(const DescribeTaskRequest& request) const
283 {
284 auto task = Aws::MakeShared< std::packaged_task< DescribeTaskOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTask(request); } );
285 auto packagedFunction = [task]() { (*task)(); };
286 m_executor->Submit(packagedFunction);
287 return task->get_future();
288 }
289
DescribeTaskAsync(const DescribeTaskRequest & request,const DescribeTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const290 void SnowDeviceManagementClient::DescribeTaskAsync(const DescribeTaskRequest& request, const DescribeTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
291 {
292 m_executor->Submit( [this, request, handler, context](){ this->DescribeTaskAsyncHelper( request, handler, context ); } );
293 }
294
DescribeTaskAsyncHelper(const DescribeTaskRequest & request,const DescribeTaskResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const295 void SnowDeviceManagementClient::DescribeTaskAsyncHelper(const DescribeTaskRequest& request, const DescribeTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
296 {
297 handler(this, request, DescribeTask(request), context);
298 }
299
ListDeviceResources(const ListDeviceResourcesRequest & request) const300 ListDeviceResourcesOutcome SnowDeviceManagementClient::ListDeviceResources(const ListDeviceResourcesRequest& request) const
301 {
302 if (!request.ManagedDeviceIdHasBeenSet())
303 {
304 AWS_LOGSTREAM_ERROR("ListDeviceResources", "Required field: ManagedDeviceId, is not set");
305 return ListDeviceResourcesOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ManagedDeviceId]", false));
306 }
307 Aws::Http::URI uri = m_uri;
308 uri.AddPathSegments("/managed-device/");
309 uri.AddPathSegment(request.GetManagedDeviceId());
310 uri.AddPathSegments("/resources");
311 return ListDeviceResourcesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
312 }
313
ListDeviceResourcesCallable(const ListDeviceResourcesRequest & request) const314 ListDeviceResourcesOutcomeCallable SnowDeviceManagementClient::ListDeviceResourcesCallable(const ListDeviceResourcesRequest& request) const
315 {
316 auto task = Aws::MakeShared< std::packaged_task< ListDeviceResourcesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDeviceResources(request); } );
317 auto packagedFunction = [task]() { (*task)(); };
318 m_executor->Submit(packagedFunction);
319 return task->get_future();
320 }
321
ListDeviceResourcesAsync(const ListDeviceResourcesRequest & request,const ListDeviceResourcesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const322 void SnowDeviceManagementClient::ListDeviceResourcesAsync(const ListDeviceResourcesRequest& request, const ListDeviceResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
323 {
324 m_executor->Submit( [this, request, handler, context](){ this->ListDeviceResourcesAsyncHelper( request, handler, context ); } );
325 }
326
ListDeviceResourcesAsyncHelper(const ListDeviceResourcesRequest & request,const ListDeviceResourcesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const327 void SnowDeviceManagementClient::ListDeviceResourcesAsyncHelper(const ListDeviceResourcesRequest& request, const ListDeviceResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
328 {
329 handler(this, request, ListDeviceResources(request), context);
330 }
331
ListDevices(const ListDevicesRequest & request) const332 ListDevicesOutcome SnowDeviceManagementClient::ListDevices(const ListDevicesRequest& request) const
333 {
334 Aws::Http::URI uri = m_uri;
335 uri.AddPathSegments("/managed-devices");
336 return ListDevicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
337 }
338
ListDevicesCallable(const ListDevicesRequest & request) const339 ListDevicesOutcomeCallable SnowDeviceManagementClient::ListDevicesCallable(const ListDevicesRequest& request) const
340 {
341 auto task = Aws::MakeShared< std::packaged_task< ListDevicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDevices(request); } );
342 auto packagedFunction = [task]() { (*task)(); };
343 m_executor->Submit(packagedFunction);
344 return task->get_future();
345 }
346
ListDevicesAsync(const ListDevicesRequest & request,const ListDevicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const347 void SnowDeviceManagementClient::ListDevicesAsync(const ListDevicesRequest& request, const ListDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
348 {
349 m_executor->Submit( [this, request, handler, context](){ this->ListDevicesAsyncHelper( request, handler, context ); } );
350 }
351
ListDevicesAsyncHelper(const ListDevicesRequest & request,const ListDevicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const352 void SnowDeviceManagementClient::ListDevicesAsyncHelper(const ListDevicesRequest& request, const ListDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
353 {
354 handler(this, request, ListDevices(request), context);
355 }
356
ListExecutions(const ListExecutionsRequest & request) const357 ListExecutionsOutcome SnowDeviceManagementClient::ListExecutions(const ListExecutionsRequest& request) const
358 {
359 if (!request.TaskIdHasBeenSet())
360 {
361 AWS_LOGSTREAM_ERROR("ListExecutions", "Required field: TaskId, is not set");
362 return ListExecutionsOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TaskId]", false));
363 }
364 Aws::Http::URI uri = m_uri;
365 uri.AddPathSegments("/executions");
366 return ListExecutionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
367 }
368
ListExecutionsCallable(const ListExecutionsRequest & request) const369 ListExecutionsOutcomeCallable SnowDeviceManagementClient::ListExecutionsCallable(const ListExecutionsRequest& request) const
370 {
371 auto task = Aws::MakeShared< std::packaged_task< ListExecutionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListExecutions(request); } );
372 auto packagedFunction = [task]() { (*task)(); };
373 m_executor->Submit(packagedFunction);
374 return task->get_future();
375 }
376
ListExecutionsAsync(const ListExecutionsRequest & request,const ListExecutionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const377 void SnowDeviceManagementClient::ListExecutionsAsync(const ListExecutionsRequest& request, const ListExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
378 {
379 m_executor->Submit( [this, request, handler, context](){ this->ListExecutionsAsyncHelper( request, handler, context ); } );
380 }
381
ListExecutionsAsyncHelper(const ListExecutionsRequest & request,const ListExecutionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const382 void SnowDeviceManagementClient::ListExecutionsAsyncHelper(const ListExecutionsRequest& request, const ListExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
383 {
384 handler(this, request, ListExecutions(request), context);
385 }
386
ListTagsForResource(const ListTagsForResourceRequest & request) const387 ListTagsForResourceOutcome SnowDeviceManagementClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
388 {
389 if (!request.ResourceArnHasBeenSet())
390 {
391 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
392 return ListTagsForResourceOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
393 }
394 Aws::Http::URI uri = m_uri;
395 uri.AddPathSegments("/tags/");
396 uri.AddPathSegment(request.GetResourceArn());
397 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
398 }
399
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const400 ListTagsForResourceOutcomeCallable SnowDeviceManagementClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
401 {
402 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
403 auto packagedFunction = [task]() { (*task)(); };
404 m_executor->Submit(packagedFunction);
405 return task->get_future();
406 }
407
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const408 void SnowDeviceManagementClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
409 {
410 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
411 }
412
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const413 void SnowDeviceManagementClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
414 {
415 handler(this, request, ListTagsForResource(request), context);
416 }
417
ListTasks(const ListTasksRequest & request) const418 ListTasksOutcome SnowDeviceManagementClient::ListTasks(const ListTasksRequest& request) const
419 {
420 Aws::Http::URI uri = m_uri;
421 uri.AddPathSegments("/tasks");
422 return ListTasksOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
423 }
424
ListTasksCallable(const ListTasksRequest & request) const425 ListTasksOutcomeCallable SnowDeviceManagementClient::ListTasksCallable(const ListTasksRequest& request) const
426 {
427 auto task = Aws::MakeShared< std::packaged_task< ListTasksOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTasks(request); } );
428 auto packagedFunction = [task]() { (*task)(); };
429 m_executor->Submit(packagedFunction);
430 return task->get_future();
431 }
432
ListTasksAsync(const ListTasksRequest & request,const ListTasksResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const433 void SnowDeviceManagementClient::ListTasksAsync(const ListTasksRequest& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
434 {
435 m_executor->Submit( [this, request, handler, context](){ this->ListTasksAsyncHelper( request, handler, context ); } );
436 }
437
ListTasksAsyncHelper(const ListTasksRequest & request,const ListTasksResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const438 void SnowDeviceManagementClient::ListTasksAsyncHelper(const ListTasksRequest& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
439 {
440 handler(this, request, ListTasks(request), context);
441 }
442
TagResource(const TagResourceRequest & request) const443 TagResourceOutcome SnowDeviceManagementClient::TagResource(const TagResourceRequest& request) const
444 {
445 if (!request.ResourceArnHasBeenSet())
446 {
447 AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
448 return TagResourceOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
449 }
450 Aws::Http::URI uri = m_uri;
451 uri.AddPathSegments("/tags/");
452 uri.AddPathSegment(request.GetResourceArn());
453 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
454 }
455
TagResourceCallable(const TagResourceRequest & request) const456 TagResourceOutcomeCallable SnowDeviceManagementClient::TagResourceCallable(const TagResourceRequest& request) const
457 {
458 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
459 auto packagedFunction = [task]() { (*task)(); };
460 m_executor->Submit(packagedFunction);
461 return task->get_future();
462 }
463
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const464 void SnowDeviceManagementClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
465 {
466 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
467 }
468
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const469 void SnowDeviceManagementClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
470 {
471 handler(this, request, TagResource(request), context);
472 }
473
UntagResource(const UntagResourceRequest & request) const474 UntagResourceOutcome SnowDeviceManagementClient::UntagResource(const UntagResourceRequest& request) const
475 {
476 if (!request.ResourceArnHasBeenSet())
477 {
478 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
479 return UntagResourceOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
480 }
481 if (!request.TagKeysHasBeenSet())
482 {
483 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
484 return UntagResourceOutcome(Aws::Client::AWSError<SnowDeviceManagementErrors>(SnowDeviceManagementErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
485 }
486 Aws::Http::URI uri = m_uri;
487 uri.AddPathSegments("/tags/");
488 uri.AddPathSegment(request.GetResourceArn());
489 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
490 }
491
UntagResourceCallable(const UntagResourceRequest & request) const492 UntagResourceOutcomeCallable SnowDeviceManagementClient::UntagResourceCallable(const UntagResourceRequest& request) const
493 {
494 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
495 auto packagedFunction = [task]() { (*task)(); };
496 m_executor->Submit(packagedFunction);
497 return task->get_future();
498 }
499
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const500 void SnowDeviceManagementClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
501 {
502 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
503 }
504
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const505 void SnowDeviceManagementClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
506 {
507 handler(this, request, UntagResource(request), context);
508 }
509
510