AWS SDK for C++

AWS SDK for C++ Version 1.11.777
Loading...
Searching...
No Matches
DeadlineWaiter.h
1
6#pragma once
7#include <aws/core/utils/Waiter.h>
8#include <aws/core/utils/memory/AWSMemory.h>
9#include <aws/deadline/DeadlineClient.h>
10#include <aws/deadline/model/FleetStatus.h>
11#include <aws/deadline/model/GetFleetRequest.h>
12#include <aws/deadline/model/GetFleetResult.h>
13#include <aws/deadline/model/GetJobRequest.h>
14#include <aws/deadline/model/GetJobResult.h>
15#include <aws/deadline/model/GetLicenseEndpointRequest.h>
16#include <aws/deadline/model/GetLicenseEndpointResult.h>
17#include <aws/deadline/model/GetQueueFleetAssociationRequest.h>
18#include <aws/deadline/model/GetQueueFleetAssociationResult.h>
19#include <aws/deadline/model/GetQueueLimitAssociationRequest.h>
20#include <aws/deadline/model/GetQueueLimitAssociationResult.h>
21#include <aws/deadline/model/GetQueueRequest.h>
22#include <aws/deadline/model/GetQueueResult.h>
23#include <aws/deadline/model/JobLifecycleStatus.h>
24#include <aws/deadline/model/LicenseEndpointStatus.h>
25#include <aws/deadline/model/QueueFleetAssociationStatus.h>
26#include <aws/deadline/model/QueueLimitAssociationStatus.h>
27#include <aws/deadline/model/QueueStatus.h>
28#include <aws/deadline/model/TaskRunStatus.h>
29
30#include <algorithm>
31
32namespace Aws {
33namespace deadline {
34
35template <typename DerivedClient = DeadlineClient>
36class DeadlineWaiter {
37 public:
38 Aws::Utils::WaiterOutcome<Model::GetFleetOutcome> WaitUntilFleetActive(const Model::GetFleetRequest& request) {
39 using OutcomeT = Model::GetFleetOutcome;
40 using RequestT = Model::GetFleetRequest;
41 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
42 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
43 "FleetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"),
44 [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
45 if (!outcome.IsSuccess()) return false;
46 const auto& result = outcome.GetResult();
47 return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get<Aws::String>();
48 }));
49 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
50 "FleetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
51 [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
52 if (!outcome.IsSuccess()) return false;
53 const auto& result = outcome.GetResult();
54 return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get<Aws::String>();
55 }));
56 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
57 "FleetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"),
58 [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
59 if (!outcome.IsSuccess()) return false;
60 const auto& result = outcome.GetResult();
61 return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get<Aws::String>();
62 }));
63
64 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetFleet(req); };
65 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 180, std::move(acceptors), operation, "WaitUntilFleetActive");
66 return waiter.Wait(request);
67 }
68
69 Aws::Utils::WaiterOutcome<Model::GetJobOutcome> WaitUntilJobCreateComplete(const Model::GetJobRequest& request) {
70 using OutcomeT = Model::GetJobOutcome;
71 using RequestT = Model::GetJobRequest;
72 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
73 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
74 "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"),
75 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
76 if (!outcome.IsSuccess()) return false;
77 const auto& result = outcome.GetResult();
78 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
79 }));
80 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
81 "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_IN_PROGRESS"),
82 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
83 if (!outcome.IsSuccess()) return false;
84 const auto& result = outcome.GetResult();
85 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
86 }));
87 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
88 "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_FAILED"),
89 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
90 if (!outcome.IsSuccess()) return false;
91 const auto& result = outcome.GetResult();
92 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
93 }));
94 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
95 "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_SUCCEEDED"),
96 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
97 if (!outcome.IsSuccess()) return false;
98 const auto& result = outcome.GetResult();
99 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
100 }));
101 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
102 "JobCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPLOAD_FAILED"),
103 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
104 if (!outcome.IsSuccess()) return false;
105 const auto& result = outcome.GetResult();
106 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
107 }));
108 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
109 "JobCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
110 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
111 if (!outcome.IsSuccess()) return false;
112 const auto& result = outcome.GetResult();
113 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
114 }));
115
116 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetJob(req); };
117 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(1, 120, std::move(acceptors), operation, "WaitUntilJobCreateComplete");
118 return waiter.Wait(request);
119 }
120
121 Aws::Utils::WaiterOutcome<Model::GetJobOutcome> WaitUntilJobComplete(const Model::GetJobRequest& request) {
122 using OutcomeT = Model::GetJobOutcome;
123 using RequestT = Model::GetJobRequest;
124 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
125 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
126 "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"),
127 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
128 if (!outcome.IsSuccess()) return false;
129 const auto& result = outcome.GetResult();
130 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
131 }));
132 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
133 "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("FAILED"),
134 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
135 if (!outcome.IsSuccess()) return false;
136 const auto& result = outcome.GetResult();
137 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
138 }));
139 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
140 "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELED"),
141 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
142 if (!outcome.IsSuccess()) return false;
143 const auto& result = outcome.GetResult();
144 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
145 }));
146 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
147 "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUSPENDED"),
148 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
149 if (!outcome.IsSuccess()) return false;
150 const auto& result = outcome.GetResult();
151 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
152 }));
153 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
154 "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("NOT_COMPATIBLE"),
155 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
156 if (!outcome.IsSuccess()) return false;
157 const auto& result = outcome.GetResult();
158 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
159 }));
160 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
161 "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ARCHIVED"),
162 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
163 if (!outcome.IsSuccess()) return false;
164 const auto& result = outcome.GetResult();
165 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
166 }));
167
168 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetJob(req); };
169 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 240, std::move(acceptors), operation, "WaitUntilJobComplete");
170 return waiter.Wait(request);
171 }
172
173 Aws::Utils::WaiterOutcome<Model::GetJobOutcome> WaitUntilJobSucceeded(const Model::GetJobRequest& request) {
174 using OutcomeT = Model::GetJobOutcome;
175 using RequestT = Model::GetJobRequest;
176 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
177 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
178 "JobSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"),
179 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
180 if (!outcome.IsSuccess()) return false;
181 const auto& result = outcome.GetResult();
182 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
183 }));
184 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
185 "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
186 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
187 if (!outcome.IsSuccess()) return false;
188 const auto& result = outcome.GetResult();
189 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
190 }));
191 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
192 "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELED"),
193 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
194 if (!outcome.IsSuccess()) return false;
195 const auto& result = outcome.GetResult();
196 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
197 }));
198 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
199 "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("SUSPENDED"),
200 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
201 if (!outcome.IsSuccess()) return false;
202 const auto& result = outcome.GetResult();
203 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
204 }));
205 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
206 "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NOT_COMPATIBLE"),
207 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
208 if (!outcome.IsSuccess()) return false;
209 const auto& result = outcome.GetResult();
210 return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get<Aws::String>();
211 }));
212 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
213 "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ARCHIVED"),
214 [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
215 if (!outcome.IsSuccess()) return false;
216 const auto& result = outcome.GetResult();
217 return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get<Aws::String>();
218 }));
219
220 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetJob(req); };
221 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 240, std::move(acceptors), operation, "WaitUntilJobSucceeded");
222 return waiter.Wait(request);
223 }
224
225 Aws::Utils::WaiterOutcome<Model::GetLicenseEndpointOutcome> WaitUntilLicenseEndpointValid(
226 const Model::GetLicenseEndpointRequest& request) {
227 using OutcomeT = Model::GetLicenseEndpointOutcome;
228 using RequestT = Model::GetLicenseEndpointRequest;
229 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
230 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
231 "LicenseEndpointValidWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"),
232 [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
233 if (!outcome.IsSuccess()) return false;
234 const auto& result = outcome.GetResult();
235 return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == expected.get<Aws::String>();
236 }));
237 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
238 "LicenseEndpointValidWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NOT_READY"),
239 [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
240 if (!outcome.IsSuccess()) return false;
241 const auto& result = outcome.GetResult();
242 return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == expected.get<Aws::String>();
243 }));
244
245 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetLicenseEndpoint(req); };
246 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 114, std::move(acceptors), operation, "WaitUntilLicenseEndpointValid");
247 return waiter.Wait(request);
248 }
249
250 Aws::Utils::WaiterOutcome<Model::GetLicenseEndpointOutcome> WaitUntilLicenseEndpointDeleted(
251 const Model::GetLicenseEndpointRequest& request) {
252 using OutcomeT = Model::GetLicenseEndpointOutcome;
253 using RequestT = Model::GetLicenseEndpointRequest;
254 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
255 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
256 "LicenseEndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException")));
257 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
258 "LicenseEndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NOT_READY"),
259 [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
260 if (!outcome.IsSuccess()) return false;
261 const auto& result = outcome.GetResult();
262 return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == expected.get<Aws::String>();
263 }));
264
265 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetLicenseEndpoint(req); };
266 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 234, std::move(acceptors), operation, "WaitUntilLicenseEndpointDeleted");
267 return waiter.Wait(request);
268 }
269
270 Aws::Utils::WaiterOutcome<Model::GetQueueOutcome> WaitUntilQueueSchedulingBlocked(const Model::GetQueueRequest& request) {
271 using OutcomeT = Model::GetQueueOutcome;
272 using RequestT = Model::GetQueueRequest;
273 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
274 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
275 "QueueSchedulingBlockedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULING_BLOCKED"),
276 [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
277 if (!outcome.IsSuccess()) return false;
278 const auto& result = outcome.GetResult();
279 return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get<Aws::String>();
280 }));
281
282 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetQueue(req); };
283 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 30, std::move(acceptors), operation, "WaitUntilQueueSchedulingBlocked");
284 return waiter.Wait(request);
285 }
286
287 Aws::Utils::WaiterOutcome<Model::GetQueueOutcome> WaitUntilQueueScheduling(const Model::GetQueueRequest& request) {
288 using OutcomeT = Model::GetQueueOutcome;
289 using RequestT = Model::GetQueueRequest;
290 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
291 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
292 "QueueSchedulingWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULING"),
293 [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
294 if (!outcome.IsSuccess()) return false;
295 const auto& result = outcome.GetResult();
296 return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get<Aws::String>();
297 }));
298
299 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetQueue(req); };
300 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 70, std::move(acceptors), operation, "WaitUntilQueueScheduling");
301 return waiter.Wait(request);
302 }
303
304 Aws::Utils::WaiterOutcome<Model::GetQueueFleetAssociationOutcome> WaitUntilQueueFleetAssociationStopped(
305 const Model::GetQueueFleetAssociationRequest& request) {
306 using OutcomeT = Model::GetQueueFleetAssociationOutcome;
307 using RequestT = Model::GetQueueFleetAssociationRequest;
308 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
309 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
310 "QueueFleetAssociationStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"),
311 [](const Model::GetQueueFleetAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
312 if (!outcome.IsSuccess()) return false;
313 const auto& result = outcome.GetResult();
314 return Model::QueueFleetAssociationStatusMapper::GetNameForQueueFleetAssociationStatus(result.GetStatus()) ==
315 expected.get<Aws::String>();
316 }));
317
318 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetQueueFleetAssociation(req); };
319 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 60, std::move(acceptors), operation, "WaitUntilQueueFleetAssociationStopped");
320 return waiter.Wait(request);
321 }
322
323 Aws::Utils::WaiterOutcome<Model::GetQueueLimitAssociationOutcome> WaitUntilQueueLimitAssociationStopped(
324 const Model::GetQueueLimitAssociationRequest& request) {
325 using OutcomeT = Model::GetQueueLimitAssociationOutcome;
326 using RequestT = Model::GetQueueLimitAssociationRequest;
327 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
328 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
329 "QueueLimitAssociationStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"),
330 [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
331 if (!outcome.IsSuccess()) return false;
332 const auto& result = outcome.GetResult();
333 return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) ==
334 expected.get<Aws::String>();
335 }));
336
337 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetQueueLimitAssociation(req); };
338 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 60, std::move(acceptors), operation, "WaitUntilQueueLimitAssociationStopped");
339 return waiter.Wait(request);
340 }
341};
342} // namespace deadline
343} // namespace Aws
Aws::Utils::Outcome::IsSuccess
bool IsSuccess() const
Aws::Utils::Outcome::GetResult
const R & GetResult() const
Aws::Utils::Waiter::Wait
WaiterOutcome< OutcomeT > Wait(const RequestT &request)
Aws::deadline::DeadlineWaiter::WaitUntilFleetActive
Aws::Utils::WaiterOutcome< Model::GetFleetOutcome > WaitUntilFleetActive(const Model::GetFleetRequest &request)
Definition DeadlineWaiter.h:38
Aws::deadline::DeadlineWaiter::WaitUntilJobComplete
Aws::Utils::WaiterOutcome< Model::GetJobOutcome > WaitUntilJobComplete(const Model::GetJobRequest &request)
Definition DeadlineWaiter.h:121
Aws::deadline::DeadlineWaiter::WaitUntilQueueSchedulingBlocked
Aws::Utils::WaiterOutcome< Model::GetQueueOutcome > WaitUntilQueueSchedulingBlocked(const Model::GetQueueRequest &request)
Definition DeadlineWaiter.h:270
Aws::deadline::DeadlineWaiter::WaitUntilQueueFleetAssociationStopped
Aws::Utils::WaiterOutcome< Model::GetQueueFleetAssociationOutcome > WaitUntilQueueFleetAssociationStopped(const Model::GetQueueFleetAssociationRequest &request)
Definition DeadlineWaiter.h:304
Aws::deadline::DeadlineWaiter::WaitUntilQueueScheduling
Aws::Utils::WaiterOutcome< Model::GetQueueOutcome > WaitUntilQueueScheduling(const Model::GetQueueRequest &request)
Definition DeadlineWaiter.h:287
Aws::deadline::DeadlineWaiter::WaitUntilJobSucceeded
Aws::Utils::WaiterOutcome< Model::GetJobOutcome > WaitUntilJobSucceeded(const Model::GetJobRequest &request)
Definition DeadlineWaiter.h:173
Aws::deadline::DeadlineWaiter::WaitUntilLicenseEndpointValid
Aws::Utils::WaiterOutcome< Model::GetLicenseEndpointOutcome > WaitUntilLicenseEndpointValid(const Model::GetLicenseEndpointRequest &request)
Definition DeadlineWaiter.h:225
Aws::deadline::DeadlineWaiter::WaitUntilQueueLimitAssociationStopped
Aws::Utils::WaiterOutcome< Model::GetQueueLimitAssociationOutcome > WaitUntilQueueLimitAssociationStopped(const Model::GetQueueLimitAssociationRequest &request)
Definition DeadlineWaiter.h:323
Aws::deadline::DeadlineWaiter::WaitUntilJobCreateComplete
Aws::Utils::WaiterOutcome< Model::GetJobOutcome > WaitUntilJobCreateComplete(const Model::GetJobRequest &request)
Definition DeadlineWaiter.h:69
Aws::deadline::DeadlineWaiter::WaitUntilLicenseEndpointDeleted
Aws::Utils::WaiterOutcome< Model::GetLicenseEndpointOutcome > WaitUntilLicenseEndpointDeleted(const Model::GetLicenseEndpointRequest &request)
Definition DeadlineWaiter.h:250
Aws::Utils::ExpectedValue
Crt::Variant< int, bool, Aws::String > ExpectedValue
Aws::deadline::Model::FleetStatusMapper::GetNameForFleetStatus
AWS_DEADLINE_API Aws::String GetNameForFleetStatus(FleetStatus value)
Aws::deadline::Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus
AWS_DEADLINE_API Aws::String GetNameForJobLifecycleStatus(JobLifecycleStatus value)
Aws::deadline::Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus
AWS_DEADLINE_API Aws::String GetNameForLicenseEndpointStatus(LicenseEndpointStatus value)
Aws::deadline::Model::QueueFleetAssociationStatusMapper::GetNameForQueueFleetAssociationStatus
AWS_DEADLINE_API Aws::String GetNameForQueueFleetAssociationStatus(QueueFleetAssociationStatus value)
Aws::deadline::Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus
AWS_DEADLINE_API Aws::String GetNameForQueueLimitAssociationStatus(QueueLimitAssociationStatus value)
Aws::deadline::Model::QueueStatusMapper::GetNameForQueueStatus
AWS_DEADLINE_API Aws::String GetNameForQueueStatus(QueueStatus value)
Aws::deadline::Model::TaskRunStatusMapper::GetNameForTaskRunStatus
AWS_DEADLINE_API Aws::String GetNameForTaskRunStatus(TaskRunStatus value)
Aws::deadline::Model::GetQueueOutcome
Aws::Utils::Outcome< GetQueueResult, DeadlineError > GetQueueOutcome
Definition DeadlineServiceClientModel.h:336
Aws::deadline::Model::GetQueueLimitAssociationOutcome
Aws::Utils::Outcome< GetQueueLimitAssociationResult, DeadlineError > GetQueueLimitAssociationOutcome
Definition DeadlineServiceClientModel.h:339
Aws::deadline::Model::GetFleetOutcome
Aws::Utils::Outcome< GetFleetResult, DeadlineError > GetFleetOutcome
Definition DeadlineServiceClientModel.h:331
Aws::deadline::Model::GetLicenseEndpointOutcome
Aws::Utils::Outcome< GetLicenseEndpointResult, DeadlineError > GetLicenseEndpointOutcome
Definition DeadlineServiceClientModel.h:333
Aws::deadline::Model::GetJobOutcome
Aws::Utils::Outcome< GetJobResult, DeadlineError > GetJobOutcome
Definition DeadlineServiceClientModel.h:332
Aws::deadline::Model::GetQueueFleetAssociationOutcome
Aws::Utils::Outcome< GetQueueFleetAssociationResult, DeadlineError > GetQueueFleetAssociationOutcome
Definition DeadlineServiceClientModel.h:338
Aws::String
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
Aws::MakeUnique
UniquePtr< T > MakeUnique(const char *allocationTag, ArgTypes &&... args)
Aws::Vector
std::vector< T, Aws::Allocator< T > > Vector
Generated by doxygen 1.9.8
Privacy | Site terms | Cookie preferences