AWS SDK for C++

AWS SDK for C++ Version 1.11.787
Loading...
Searching...
No Matches
DatabaseMigrationServiceWaiter.h
1
6#pragma once
7#include <aws/core/utils/Waiter.h>
8#include <aws/core/utils/memory/AWSMemory.h>
9#include <aws/dms/DatabaseMigrationServiceClient.h>
10#include <aws/dms/model/DescribeConnectionsRequest.h>
11#include <aws/dms/model/DescribeConnectionsResult.h>
12#include <aws/dms/model/DescribeEndpointsRequest.h>
13#include <aws/dms/model/DescribeEndpointsResult.h>
14#include <aws/dms/model/DescribeReplicationInstancesRequest.h>
15#include <aws/dms/model/DescribeReplicationInstancesResult.h>
16#include <aws/dms/model/DescribeReplicationTasksRequest.h>
17#include <aws/dms/model/DescribeReplicationTasksResult.h>
18
19#include <algorithm>
20
21namespace Aws {
22namespace DatabaseMigrationService {
23
24template <typename DerivedClient = DatabaseMigrationServiceClient>
25class DatabaseMigrationServiceWaiter {
26 public:
27 Aws::Utils::WaiterOutcome<Model::DescribeConnectionsOutcome> WaitUntilTestConnectionSucceeds(
28 const Model::DescribeConnectionsRequest& request) {
29 using OutcomeT = Model::DescribeConnectionsOutcome;
30 using RequestT = Model::DescribeConnectionsRequest;
31 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
32 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
33 "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("successful"),
34 [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
35 if (!outcome.IsSuccess()) return false;
36 const auto& result = outcome.GetResult();
37 return std::all_of(result.GetConnections().begin(), result.GetConnections().end(),
38 [&](const Model::Connection& item) { return item.GetStatus() == expected.get<Aws::String>(); });
39 }));
40 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
41 "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
42 [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
43 if (!outcome.IsSuccess()) return false;
44 const auto& result = outcome.GetResult();
45 return std::any_of(result.GetConnections().begin(), result.GetConnections().end(),
46 [&](const Model::Connection& item) { return item.GetStatus() == expected.get<Aws::String>(); });
47 }));
48
49 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeConnections(req); };
50 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilTestConnectionSucceeds");
51 return waiter.Wait(request);
52 }
53
54 Aws::Utils::WaiterOutcome<Model::DescribeEndpointsOutcome> WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest& request) {
55 using OutcomeT = Model::DescribeEndpointsOutcome;
56 using RequestT = Model::DescribeEndpointsRequest;
57 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
58 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("EndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS,
59 Aws::String("ResourceNotFoundFault")));
60 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
61 "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("active"),
62 [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
63 if (!outcome.IsSuccess()) return false;
64 const auto& result = outcome.GetResult();
65 return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(),
66 [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get<Aws::String>(); });
67 }));
68 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
69 "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
70 [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
71 if (!outcome.IsSuccess()) return false;
72 const auto& result = outcome.GetResult();
73 return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(),
74 [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get<Aws::String>(); });
75 }));
76
77 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeEndpoints(req); };
78 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilEndpointDeleted");
79 return waiter.Wait(request);
80 }
81
82 Aws::Utils::WaiterOutcome<Model::DescribeReplicationInstancesOutcome> WaitUntilReplicationInstanceAvailable(
83 const Model::DescribeReplicationInstancesRequest& request) {
84 using OutcomeT = Model::DescribeReplicationInstancesOutcome;
85 using RequestT = Model::DescribeReplicationInstancesRequest;
86 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
87 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
88 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
89 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
90 if (!outcome.IsSuccess()) return false;
91 const auto& result = outcome.GetResult();
92 return std::all_of(
93 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
94 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
95 }));
96 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
97 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
98 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
99 if (!outcome.IsSuccess()) return false;
100 const auto& result = outcome.GetResult();
101 return std::any_of(
102 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
103 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
104 }));
105 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
106 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-credentials"),
107 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
108 if (!outcome.IsSuccess()) return false;
109 const auto& result = outcome.GetResult();
110 return std::any_of(
111 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
112 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
113 }));
114 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
115 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-network"),
116 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
117 if (!outcome.IsSuccess()) return false;
118 const auto& result = outcome.GetResult();
119 return std::any_of(
120 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
121 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
122 }));
123 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
124 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("inaccessible-encryption-credentials"),
125 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
126 if (!outcome.IsSuccess()) return false;
127 const auto& result = outcome.GetResult();
128 return std::any_of(
129 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
130 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
131 }));
132
133 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationInstances(req); };
134 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(60, 2, std::move(acceptors), operation, "WaitUntilReplicationInstanceAvailable");
135 return waiter.Wait(request);
136 }
137
138 Aws::Utils::WaiterOutcome<Model::DescribeReplicationInstancesOutcome> WaitUntilReplicationInstanceDeleted(
139 const Model::DescribeReplicationInstancesRequest& request) {
140 using OutcomeT = Model::DescribeReplicationInstancesOutcome;
141 using RequestT = Model::DescribeReplicationInstancesRequest;
142 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
143 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
144 "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("available"),
145 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
146 if (!outcome.IsSuccess()) return false;
147 const auto& result = outcome.GetResult();
148 return std::any_of(
149 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
150 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
151 }));
152 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
153 "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault")));
154
155 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationInstances(req); };
156 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationInstanceDeleted");
157 return waiter.Wait(request);
158 }
159
160 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskDeleted(
161 const Model::DescribeReplicationTasksRequest& request) {
162 using OutcomeT = Model::DescribeReplicationTasksOutcome;
163 using RequestT = Model::DescribeReplicationTasksRequest;
164 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
165 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
166 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"),
167 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
168 if (!outcome.IsSuccess()) return false;
169 const auto& result = outcome.GetResult();
170 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
171 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
172 }));
173 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
174 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
175 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
176 if (!outcome.IsSuccess()) return false;
177 const auto& result = outcome.GetResult();
178 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
179 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
180 }));
181 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
182 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"),
183 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
184 if (!outcome.IsSuccess()) return false;
185 const auto& result = outcome.GetResult();
186 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
187 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
188 }));
189 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
190 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("running"),
191 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
192 if (!outcome.IsSuccess()) return false;
193 const auto& result = outcome.GetResult();
194 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
195 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
196 }));
197 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
198 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
199 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
200 if (!outcome.IsSuccess()) return false;
201 const auto& result = outcome.GetResult();
202 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
203 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
204 }));
205 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
206 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault")));
207
208 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
209 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskDeleted");
210 return waiter.Wait(request);
211 }
212
213 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskReady(
214 const Model::DescribeReplicationTasksRequest& request) {
215 using OutcomeT = Model::DescribeReplicationTasksOutcome;
216 using RequestT = Model::DescribeReplicationTasksRequest;
217 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
218 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
219 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ready"),
220 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
221 if (!outcome.IsSuccess()) return false;
222 const auto& result = outcome.GetResult();
223 return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
224 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
225 }));
226 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
227 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("starting"),
228 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
229 if (!outcome.IsSuccess()) return false;
230 const auto& result = outcome.GetResult();
231 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
232 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
233 }));
234 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
235 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("running"),
236 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
237 if (!outcome.IsSuccess()) return false;
238 const auto& result = outcome.GetResult();
239 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
240 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
241 }));
242 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
243 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"),
244 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
245 if (!outcome.IsSuccess()) return false;
246 const auto& result = outcome.GetResult();
247 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
248 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
249 }));
250 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
251 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"),
252 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
253 if (!outcome.IsSuccess()) return false;
254 const auto& result = outcome.GetResult();
255 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
256 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
257 }));
258 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
259 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
260 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
261 if (!outcome.IsSuccess()) return false;
262 const auto& result = outcome.GetResult();
263 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
264 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
265 }));
266 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
267 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
268 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
269 if (!outcome.IsSuccess()) return false;
270 const auto& result = outcome.GetResult();
271 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
272 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
273 }));
274 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
275 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"),
276 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
277 if (!outcome.IsSuccess()) return false;
278 const auto& result = outcome.GetResult();
279 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
280 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
281 }));
282 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
283 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
284 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
285 if (!outcome.IsSuccess()) return false;
286 const auto& result = outcome.GetResult();
287 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
288 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
289 }));
290
291 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
292 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskReady");
293 return waiter.Wait(request);
294 }
295
296 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskRunning(
297 const Model::DescribeReplicationTasksRequest& request) {
298 using OutcomeT = Model::DescribeReplicationTasksOutcome;
299 using RequestT = Model::DescribeReplicationTasksRequest;
300 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
301 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
302 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("running"),
303 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
304 if (!outcome.IsSuccess()) return false;
305 const auto& result = outcome.GetResult();
306 return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
307 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
308 }));
309 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
310 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"),
311 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
312 if (!outcome.IsSuccess()) return false;
313 const auto& result = outcome.GetResult();
314 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
315 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
316 }));
317 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
318 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
319 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
320 if (!outcome.IsSuccess()) return false;
321 const auto& result = outcome.GetResult();
322 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
323 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
324 }));
325 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
326 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"),
327 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
328 if (!outcome.IsSuccess()) return false;
329 const auto& result = outcome.GetResult();
330 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
331 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
332 }));
333 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
334 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"),
335 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
336 if (!outcome.IsSuccess()) return false;
337 const auto& result = outcome.GetResult();
338 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
339 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
340 }));
341 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
342 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
343 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
344 if (!outcome.IsSuccess()) return false;
345 const auto& result = outcome.GetResult();
346 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
347 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
348 }));
349 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
350 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
351 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
352 if (!outcome.IsSuccess()) return false;
353 const auto& result = outcome.GetResult();
354 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
355 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
356 }));
357 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
358 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"),
359 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
360 if (!outcome.IsSuccess()) return false;
361 const auto& result = outcome.GetResult();
362 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
363 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
364 }));
365 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
366 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
367 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
368 if (!outcome.IsSuccess()) return false;
369 const auto& result = outcome.GetResult();
370 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
371 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
372 }));
373
374 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
375 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskRunning");
376 return waiter.Wait(request);
377 }
378
379 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskStopped(
380 const Model::DescribeReplicationTasksRequest& request) {
381 using OutcomeT = Model::DescribeReplicationTasksOutcome;
382 using RequestT = Model::DescribeReplicationTasksRequest;
383 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
384 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
385 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("stopped"),
386 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
387 if (!outcome.IsSuccess()) return false;
388 const auto& result = outcome.GetResult();
389 return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
390 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
391 }));
392 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
393 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"),
394 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
395 if (!outcome.IsSuccess()) return false;
396 const auto& result = outcome.GetResult();
397 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
398 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
399 }));
400 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
401 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
402 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
403 if (!outcome.IsSuccess()) return false;
404 const auto& result = outcome.GetResult();
405 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
406 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
407 }));
408 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
409 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("starting"),
410 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
411 if (!outcome.IsSuccess()) return false;
412 const auto& result = outcome.GetResult();
413 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
414 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
415 }));
416 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
417 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
418 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
419 if (!outcome.IsSuccess()) return false;
420 const auto& result = outcome.GetResult();
421 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
422 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
423 }));
424 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
425 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
426 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
427 if (!outcome.IsSuccess()) return false;
428 const auto& result = outcome.GetResult();
429 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
430 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
431 }));
432 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
433 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"),
434 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
435 if (!outcome.IsSuccess()) return false;
436 const auto& result = outcome.GetResult();
437 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
438 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
439 }));
440 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
441 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
442 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
443 if (!outcome.IsSuccess()) return false;
444 const auto& result = outcome.GetResult();
445 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
446 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
447 }));
448
449 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
450 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskStopped");
451 return waiter.Wait(request);
452 }
453};
454} // namespace DatabaseMigrationService
455} // namespace Aws
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilTestConnectionSucceeds
Aws::Utils::WaiterOutcome< Model::DescribeConnectionsOutcome > WaitUntilTestConnectionSucceeds(const Model::DescribeConnectionsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:27
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilEndpointDeleted
Aws::Utils::WaiterOutcome< Model::DescribeEndpointsOutcome > WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:54
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskStopped
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskStopped(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:379
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskReady
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskReady(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:213
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskDeleted
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskDeleted(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:160
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationInstanceAvailable
Aws::Utils::WaiterOutcome< Model::DescribeReplicationInstancesOutcome > WaitUntilReplicationInstanceAvailable(const Model::DescribeReplicationInstancesRequest &request)
Definition DatabaseMigrationServiceWaiter.h:82
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskRunning
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskRunning(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:296
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationInstanceDeleted
Aws::Utils::WaiterOutcome< Model::DescribeReplicationInstancesOutcome > WaitUntilReplicationInstanceDeleted(const Model::DescribeReplicationInstancesRequest &request)
Definition DatabaseMigrationServiceWaiter.h:138
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::DatabaseMigrationService::Model::DescribeEndpointsOutcome
Aws::Utils::Outcome< DescribeEndpointsResult, DatabaseMigrationServiceError > DescribeEndpointsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:375
Aws::DatabaseMigrationService::Model::DescribeReplicationTasksOutcome
Aws::Utils::Outcome< DescribeReplicationTasksResult, DatabaseMigrationServiceError > DescribeReplicationTasksOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:421
Aws::DatabaseMigrationService::Model::DescribeReplicationInstancesOutcome
Aws::Utils::Outcome< DescribeReplicationInstancesResult, DatabaseMigrationServiceError > DescribeReplicationInstancesOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:411
Aws::DatabaseMigrationService::Model::DescribeConnectionsOutcome
Aws::Utils::Outcome< DescribeConnectionsResult, DatabaseMigrationServiceError > DescribeConnectionsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:369
Aws::Utils::ExpectedValue
Crt::Variant< int, bool, Aws::String > ExpectedValue
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