AWS SDK for C++

AWS SDK for C++ Version 1.11.811
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/DescribeExtensionPackAssociationsRequest.h>
15#include <aws/dms/model/DescribeExtensionPackAssociationsResult.h>
16#include <aws/dms/model/DescribeMetadataModelAssessmentsRequest.h>
17#include <aws/dms/model/DescribeMetadataModelAssessmentsResult.h>
18#include <aws/dms/model/DescribeMetadataModelConversionsRequest.h>
19#include <aws/dms/model/DescribeMetadataModelConversionsResult.h>
20#include <aws/dms/model/DescribeMetadataModelCreationsRequest.h>
21#include <aws/dms/model/DescribeMetadataModelCreationsResult.h>
22#include <aws/dms/model/DescribeMetadataModelExportsAsScriptRequest.h>
23#include <aws/dms/model/DescribeMetadataModelExportsAsScriptResult.h>
24#include <aws/dms/model/DescribeMetadataModelExportsToTargetRequest.h>
25#include <aws/dms/model/DescribeMetadataModelExportsToTargetResult.h>
26#include <aws/dms/model/DescribeMetadataModelImportsRequest.h>
27#include <aws/dms/model/DescribeMetadataModelImportsResult.h>
28#include <aws/dms/model/DescribeReplicationInstancesRequest.h>
29#include <aws/dms/model/DescribeReplicationInstancesResult.h>
30#include <aws/dms/model/DescribeReplicationTasksRequest.h>
31#include <aws/dms/model/DescribeReplicationTasksResult.h>
32
33#include <algorithm>
34
35namespace Aws {
36namespace DatabaseMigrationService {
37
38template <typename DerivedClient = DatabaseMigrationServiceClient>
39class DatabaseMigrationServiceWaiter {
40 public:
41 Aws::Utils::WaiterOutcome<Model::DescribeConnectionsOutcome> WaitUntilTestConnectionSucceeds(
42 const Model::DescribeConnectionsRequest& request) {
43 using OutcomeT = Model::DescribeConnectionsOutcome;
44 using RequestT = Model::DescribeConnectionsRequest;
45 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
46 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
47 "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("successful"),
48 [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
49 if (!outcome.IsSuccess()) return false;
50 const auto& result = outcome.GetResult();
51 return std::all_of(result.GetConnections().begin(), result.GetConnections().end(),
52 [&](const Model::Connection& item) { return item.GetStatus() == expected.get<Aws::String>(); });
53 }));
54 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
55 "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
56 [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
57 if (!outcome.IsSuccess()) return false;
58 const auto& result = outcome.GetResult();
59 return std::any_of(result.GetConnections().begin(), result.GetConnections().end(),
60 [&](const Model::Connection& item) { return item.GetStatus() == expected.get<Aws::String>(); });
61 }));
62
63 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeConnections(req); };
64 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilTestConnectionSucceeds");
65 return waiter.Wait(request);
66 }
67
68 Aws::Utils::WaiterOutcome<Model::DescribeEndpointsOutcome> WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest& request) {
69 using OutcomeT = Model::DescribeEndpointsOutcome;
70 using RequestT = Model::DescribeEndpointsRequest;
71 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
72 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("EndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS,
73 Aws::String("ResourceNotFoundFault")));
74 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
75 "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("active"),
76 [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
77 if (!outcome.IsSuccess()) return false;
78 const auto& result = outcome.GetResult();
79 return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(),
80 [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get<Aws::String>(); });
81 }));
82 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
83 "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
84 [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
85 if (!outcome.IsSuccess()) return false;
86 const auto& result = outcome.GetResult();
87 return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(),
88 [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get<Aws::String>(); });
89 }));
90
91 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeEndpoints(req); };
92 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilEndpointDeleted");
93 return waiter.Wait(request);
94 }
95
96 Aws::Utils::WaiterOutcome<Model::DescribeExtensionPackAssociationsOutcome> WaitUntilExtensionPackAssociated(
97 const Model::DescribeExtensionPackAssociationsRequest& request) {
98 using OutcomeT = Model::DescribeExtensionPackAssociationsOutcome;
99 using RequestT = Model::DescribeExtensionPackAssociationsRequest;
100 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
101 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
102 "ExtensionPackAssociatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
103 [](const Model::DescribeExtensionPackAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
104 if (!outcome.IsSuccess()) return false;
105 const auto& result = outcome.GetResult();
106 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
107 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
108 }));
109 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
110 "ExtensionPackAssociatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
111 [](const Model::DescribeExtensionPackAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
112 if (!outcome.IsSuccess()) return false;
113 const auto& result = outcome.GetResult();
114 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
115 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
116 }));
117
118 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeExtensionPackAssociations(req); };
119 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 12, std::move(acceptors), operation, "WaitUntilExtensionPackAssociated");
120 return waiter.Wait(request);
121 }
122
123 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelAssessmentsOutcome> WaitUntilMetadataModelAssessed(
124 const Model::DescribeMetadataModelAssessmentsRequest& request) {
125 using OutcomeT = Model::DescribeMetadataModelAssessmentsOutcome;
126 using RequestT = Model::DescribeMetadataModelAssessmentsRequest;
127 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
128 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
129 "MetadataModelAssessedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
130 [](const Model::DescribeMetadataModelAssessmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
131 if (!outcome.IsSuccess()) return false;
132 const auto& result = outcome.GetResult();
133 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
134 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
135 }));
136 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
137 "MetadataModelAssessedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
138 [](const Model::DescribeMetadataModelAssessmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
139 if (!outcome.IsSuccess()) return false;
140 const auto& result = outcome.GetResult();
141 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
142 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
143 }));
144
145 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelAssessments(req); };
146 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 4, std::move(acceptors), operation, "WaitUntilMetadataModelAssessed");
147 return waiter.Wait(request);
148 }
149
150 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelConversionsOutcome> WaitUntilMetadataModelConversionCancelled(
151 const Model::DescribeMetadataModelConversionsRequest& request) {
152 using OutcomeT = Model::DescribeMetadataModelConversionsOutcome;
153 using RequestT = Model::DescribeMetadataModelConversionsRequest;
154 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
155 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
156 "MetadataModelConversionCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELED"),
157 [](const Model::DescribeMetadataModelConversionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
158 if (!outcome.IsSuccess()) return false;
159 const auto& result = outcome.GetResult();
160 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
161 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
162 }));
163 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
164 "MetadataModelConversionCancelledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
165 [](const Model::DescribeMetadataModelConversionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
166 if (!outcome.IsSuccess()) return false;
167 const auto& result = outcome.GetResult();
168 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
169 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
170 }));
171
172 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelConversions(req); };
173 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 12, std::move(acceptors), operation, "WaitUntilMetadataModelConversionCancelled");
174 return waiter.Wait(request);
175 }
176
177 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelConversionsOutcome> WaitUntilMetadataModelConverted(
178 const Model::DescribeMetadataModelConversionsRequest& request) {
179 using OutcomeT = Model::DescribeMetadataModelConversionsOutcome;
180 using RequestT = Model::DescribeMetadataModelConversionsRequest;
181 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
182 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
183 "MetadataModelConvertedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
184 [](const Model::DescribeMetadataModelConversionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
185 if (!outcome.IsSuccess()) return false;
186 const auto& result = outcome.GetResult();
187 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
188 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
189 }));
190 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
191 "MetadataModelConvertedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
192 [](const Model::DescribeMetadataModelConversionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
193 if (!outcome.IsSuccess()) return false;
194 const auto& result = outcome.GetResult();
195 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
196 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
197 }));
198
199 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelConversions(req); };
200 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 4, std::move(acceptors), operation, "WaitUntilMetadataModelConverted");
201 return waiter.Wait(request);
202 }
203
204 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelCreationsOutcome> WaitUntilMetadataModelCreated(
205 const Model::DescribeMetadataModelCreationsRequest& request) {
206 using OutcomeT = Model::DescribeMetadataModelCreationsOutcome;
207 using RequestT = Model::DescribeMetadataModelCreationsRequest;
208 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
209 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
210 "MetadataModelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
211 [](const Model::DescribeMetadataModelCreationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
212 if (!outcome.IsSuccess()) return false;
213 const auto& result = outcome.GetResult();
214 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
215 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
216 }));
217 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
218 "MetadataModelCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
219 [](const Model::DescribeMetadataModelCreationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
220 if (!outcome.IsSuccess()) return false;
221 const auto& result = outcome.GetResult();
222 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
223 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
224 }));
225
226 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelCreations(req); };
227 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilMetadataModelCreated");
228 return waiter.Wait(request);
229 }
230
231 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelCreationsOutcome> WaitUntilMetadataModelCreationCancelled(
232 const Model::DescribeMetadataModelCreationsRequest& request) {
233 using OutcomeT = Model::DescribeMetadataModelCreationsOutcome;
234 using RequestT = Model::DescribeMetadataModelCreationsRequest;
235 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
236 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
237 "MetadataModelCreationCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELED"),
238 [](const Model::DescribeMetadataModelCreationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
239 if (!outcome.IsSuccess()) return false;
240 const auto& result = outcome.GetResult();
241 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
242 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
243 }));
244 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
245 "MetadataModelCreationCancelledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
246 [](const Model::DescribeMetadataModelCreationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
247 if (!outcome.IsSuccess()) return false;
248 const auto& result = outcome.GetResult();
249 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
250 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
251 }));
252
253 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelCreations(req); };
254 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(10, 12, std::move(acceptors), operation, "WaitUntilMetadataModelCreationCancelled");
255 return waiter.Wait(request);
256 }
257
258 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelExportsAsScriptOutcome> WaitUntilMetadataModelExportedAsScript(
259 const Model::DescribeMetadataModelExportsAsScriptRequest& request) {
260 using OutcomeT = Model::DescribeMetadataModelExportsAsScriptOutcome;
261 using RequestT = Model::DescribeMetadataModelExportsAsScriptRequest;
262 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
263 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
264 "MetadataModelExportedAsScriptWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
265 [](const Model::DescribeMetadataModelExportsAsScriptOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
266 if (!outcome.IsSuccess()) return false;
267 const auto& result = outcome.GetResult();
268 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
269 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
270 }));
271 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
272 "MetadataModelExportedAsScriptWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
273 [](const Model::DescribeMetadataModelExportsAsScriptOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
274 if (!outcome.IsSuccess()) return false;
275 const auto& result = outcome.GetResult();
276 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
277 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
278 }));
279
280 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelExportsAsScript(req); };
281 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(20, 6, std::move(acceptors), operation, "WaitUntilMetadataModelExportedAsScript");
282 return waiter.Wait(request);
283 }
284
285 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelExportsToTargetOutcome> WaitUntilMetadataModelExportedToTarget(
286 const Model::DescribeMetadataModelExportsToTargetRequest& request) {
287 using OutcomeT = Model::DescribeMetadataModelExportsToTargetOutcome;
288 using RequestT = Model::DescribeMetadataModelExportsToTargetRequest;
289 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
290 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
291 "MetadataModelExportedToTargetWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
292 [](const Model::DescribeMetadataModelExportsToTargetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
293 if (!outcome.IsSuccess()) return false;
294 const auto& result = outcome.GetResult();
295 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
296 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
297 }));
298 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
299 "MetadataModelExportedToTargetWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
300 [](const Model::DescribeMetadataModelExportsToTargetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
301 if (!outcome.IsSuccess()) return false;
302 const auto& result = outcome.GetResult();
303 return std::any_of(result.GetRequests().begin(), result.GetRequests().end(),
304 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
305 }));
306
307 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelExportsToTarget(req); };
308 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(20, 6, std::move(acceptors), operation, "WaitUntilMetadataModelExportedToTarget");
309 return waiter.Wait(request);
310 }
311
312 Aws::Utils::WaiterOutcome<Model::DescribeMetadataModelImportsOutcome> WaitUntilMetadataModelImported(
313 const Model::DescribeMetadataModelImportsRequest& request) {
314 using OutcomeT = Model::DescribeMetadataModelImportsOutcome;
315 using RequestT = Model::DescribeMetadataModelImportsRequest;
316 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
317 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
318 "MetadataModelImportedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"),
319 [](const Model::DescribeMetadataModelImportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
320 if (!outcome.IsSuccess()) return false;
321 const auto& result = outcome.GetResult();
322 return std::all_of(result.GetRequests().begin(), result.GetRequests().end(),
323 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
324 }));
325 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
326 "MetadataModelImportedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"),
327 [](const Model::DescribeMetadataModelImportsOutcome& 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.GetRequests().begin(), result.GetRequests().end(),
331 [&](const Model::SchemaConversionRequest& item) { return item.GetStatus() == expected.get<Aws::String>(); });
332 }));
333
334 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMetadataModelImports(req); };
335 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(60, 2, std::move(acceptors), operation, "WaitUntilMetadataModelImported");
336 return waiter.Wait(request);
337 }
338
339 Aws::Utils::WaiterOutcome<Model::DescribeReplicationInstancesOutcome> WaitUntilReplicationInstanceAvailable(
340 const Model::DescribeReplicationInstancesRequest& request) {
341 using OutcomeT = Model::DescribeReplicationInstancesOutcome;
342 using RequestT = Model::DescribeReplicationInstancesRequest;
343 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
344 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
345 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
346 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
347 if (!outcome.IsSuccess()) return false;
348 const auto& result = outcome.GetResult();
349 return std::all_of(
350 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
351 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
352 }));
353 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
354 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
355 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
356 if (!outcome.IsSuccess()) return false;
357 const auto& result = outcome.GetResult();
358 return std::any_of(
359 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
360 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
361 }));
362 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
363 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-credentials"),
364 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
365 if (!outcome.IsSuccess()) return false;
366 const auto& result = outcome.GetResult();
367 return std::any_of(
368 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
369 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
370 }));
371 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
372 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-network"),
373 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
374 if (!outcome.IsSuccess()) return false;
375 const auto& result = outcome.GetResult();
376 return std::any_of(
377 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
378 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
379 }));
380 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
381 "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("inaccessible-encryption-credentials"),
382 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
383 if (!outcome.IsSuccess()) return false;
384 const auto& result = outcome.GetResult();
385 return std::any_of(
386 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
387 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
388 }));
389
390 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationInstances(req); };
391 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(60, 2, std::move(acceptors), operation, "WaitUntilReplicationInstanceAvailable");
392 return waiter.Wait(request);
393 }
394
395 Aws::Utils::WaiterOutcome<Model::DescribeReplicationInstancesOutcome> WaitUntilReplicationInstanceDeleted(
396 const Model::DescribeReplicationInstancesRequest& request) {
397 using OutcomeT = Model::DescribeReplicationInstancesOutcome;
398 using RequestT = Model::DescribeReplicationInstancesRequest;
399 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
400 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
401 "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("available"),
402 [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
403 if (!outcome.IsSuccess()) return false;
404 const auto& result = outcome.GetResult();
405 return std::any_of(
406 result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(),
407 [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get<Aws::String>(); });
408 }));
409 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
410 "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault")));
411
412 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationInstances(req); };
413 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationInstanceDeleted");
414 return waiter.Wait(request);
415 }
416
417 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskDeleted(
418 const Model::DescribeReplicationTasksRequest& request) {
419 using OutcomeT = Model::DescribeReplicationTasksOutcome;
420 using RequestT = Model::DescribeReplicationTasksRequest;
421 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
422 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
423 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"),
424 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
425 if (!outcome.IsSuccess()) return false;
426 const auto& result = outcome.GetResult();
427 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
428 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
429 }));
430 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
431 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
432 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
433 if (!outcome.IsSuccess()) return false;
434 const auto& result = outcome.GetResult();
435 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
436 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
437 }));
438 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
439 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"),
440 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
441 if (!outcome.IsSuccess()) return false;
442 const auto& result = outcome.GetResult();
443 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
444 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
445 }));
446 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
447 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("running"),
448 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
449 if (!outcome.IsSuccess()) return false;
450 const auto& result = outcome.GetResult();
451 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
452 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
453 }));
454 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
455 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
456 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
457 if (!outcome.IsSuccess()) return false;
458 const auto& result = outcome.GetResult();
459 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
460 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
461 }));
462 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
463 "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault")));
464
465 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
466 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskDeleted");
467 return waiter.Wait(request);
468 }
469
470 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskReady(
471 const Model::DescribeReplicationTasksRequest& request) {
472 using OutcomeT = Model::DescribeReplicationTasksOutcome;
473 using RequestT = Model::DescribeReplicationTasksRequest;
474 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
475 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
476 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ready"),
477 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
478 if (!outcome.IsSuccess()) return false;
479 const auto& result = outcome.GetResult();
480 return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
481 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
482 }));
483 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
484 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("starting"),
485 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
486 if (!outcome.IsSuccess()) return false;
487 const auto& result = outcome.GetResult();
488 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
489 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
490 }));
491 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
492 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("running"),
493 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
494 if (!outcome.IsSuccess()) return false;
495 const auto& result = outcome.GetResult();
496 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
497 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
498 }));
499 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
500 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"),
501 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
502 if (!outcome.IsSuccess()) return false;
503 const auto& result = outcome.GetResult();
504 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
505 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
506 }));
507 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
508 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"),
509 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
510 if (!outcome.IsSuccess()) return false;
511 const auto& result = outcome.GetResult();
512 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
513 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
514 }));
515 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
516 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
517 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
518 if (!outcome.IsSuccess()) return false;
519 const auto& result = outcome.GetResult();
520 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
521 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
522 }));
523 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
524 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
525 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
526 if (!outcome.IsSuccess()) return false;
527 const auto& result = outcome.GetResult();
528 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
529 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
530 }));
531 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
532 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"),
533 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
534 if (!outcome.IsSuccess()) return false;
535 const auto& result = outcome.GetResult();
536 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
537 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
538 }));
539 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
540 "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
541 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
542 if (!outcome.IsSuccess()) return false;
543 const auto& result = outcome.GetResult();
544 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
545 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
546 }));
547
548 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
549 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskReady");
550 return waiter.Wait(request);
551 }
552
553 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskRunning(
554 const Model::DescribeReplicationTasksRequest& request) {
555 using OutcomeT = Model::DescribeReplicationTasksOutcome;
556 using RequestT = Model::DescribeReplicationTasksRequest;
557 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
558 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
559 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("running"),
560 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
561 if (!outcome.IsSuccess()) return false;
562 const auto& result = outcome.GetResult();
563 return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
564 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
565 }));
566 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
567 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"),
568 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
569 if (!outcome.IsSuccess()) return false;
570 const auto& result = outcome.GetResult();
571 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
572 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
573 }));
574 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
575 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
576 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
577 if (!outcome.IsSuccess()) return false;
578 const auto& result = outcome.GetResult();
579 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
580 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
581 }));
582 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
583 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"),
584 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
585 if (!outcome.IsSuccess()) return false;
586 const auto& result = outcome.GetResult();
587 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
588 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
589 }));
590 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
591 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"),
592 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
593 if (!outcome.IsSuccess()) return false;
594 const auto& result = outcome.GetResult();
595 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
596 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
597 }));
598 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
599 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
600 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
601 if (!outcome.IsSuccess()) return false;
602 const auto& result = outcome.GetResult();
603 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
604 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
605 }));
606 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
607 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
608 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
609 if (!outcome.IsSuccess()) return false;
610 const auto& result = outcome.GetResult();
611 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
612 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
613 }));
614 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
615 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"),
616 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
617 if (!outcome.IsSuccess()) return false;
618 const auto& result = outcome.GetResult();
619 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
620 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
621 }));
622 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
623 "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
624 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
625 if (!outcome.IsSuccess()) return false;
626 const auto& result = outcome.GetResult();
627 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
628 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
629 }));
630
631 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
632 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskRunning");
633 return waiter.Wait(request);
634 }
635
636 Aws::Utils::WaiterOutcome<Model::DescribeReplicationTasksOutcome> WaitUntilReplicationTaskStopped(
637 const Model::DescribeReplicationTasksRequest& request) {
638 using OutcomeT = Model::DescribeReplicationTasksOutcome;
639 using RequestT = Model::DescribeReplicationTasksRequest;
640 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
641 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
642 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("stopped"),
643 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
644 if (!outcome.IsSuccess()) return false;
645 const auto& result = outcome.GetResult();
646 return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
647 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
648 }));
649 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
650 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"),
651 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
652 if (!outcome.IsSuccess()) return false;
653 const auto& result = outcome.GetResult();
654 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
655 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
656 }));
657 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
658 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
659 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
660 if (!outcome.IsSuccess()) return false;
661 const auto& result = outcome.GetResult();
662 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
663 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
664 }));
665 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
666 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("starting"),
667 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
668 if (!outcome.IsSuccess()) return false;
669 const auto& result = outcome.GetResult();
670 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
671 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
672 }));
673 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
674 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
675 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
676 if (!outcome.IsSuccess()) return false;
677 const auto& result = outcome.GetResult();
678 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
679 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
680 }));
681 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
682 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
683 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
684 if (!outcome.IsSuccess()) return false;
685 const auto& result = outcome.GetResult();
686 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
687 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
688 }));
689 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
690 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"),
691 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
692 if (!outcome.IsSuccess()) return false;
693 const auto& result = outcome.GetResult();
694 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
695 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
696 }));
697 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
698 "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
699 [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
700 if (!outcome.IsSuccess()) return false;
701 const auto& result = outcome.GetResult();
702 return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(),
703 [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get<Aws::String>(); });
704 }));
705
706 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeReplicationTasks(req); };
707 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskStopped");
708 return waiter.Wait(request);
709 }
710};
711} // namespace DatabaseMigrationService
712} // namespace Aws
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilExtensionPackAssociated
Aws::Utils::WaiterOutcome< Model::DescribeExtensionPackAssociationsOutcome > WaitUntilExtensionPackAssociated(const Model::DescribeExtensionPackAssociationsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:96
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilTestConnectionSucceeds
Aws::Utils::WaiterOutcome< Model::DescribeConnectionsOutcome > WaitUntilTestConnectionSucceeds(const Model::DescribeConnectionsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:41
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilEndpointDeleted
Aws::Utils::WaiterOutcome< Model::DescribeEndpointsOutcome > WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:68
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskStopped
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskStopped(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:636
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskReady
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskReady(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:470
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelConverted
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelConversionsOutcome > WaitUntilMetadataModelConverted(const Model::DescribeMetadataModelConversionsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:177
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelImported
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelImportsOutcome > WaitUntilMetadataModelImported(const Model::DescribeMetadataModelImportsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:312
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelAssessed
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelAssessmentsOutcome > WaitUntilMetadataModelAssessed(const Model::DescribeMetadataModelAssessmentsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:123
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelCreated
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelCreationsOutcome > WaitUntilMetadataModelCreated(const Model::DescribeMetadataModelCreationsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:204
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelExportedToTarget
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelExportsToTargetOutcome > WaitUntilMetadataModelExportedToTarget(const Model::DescribeMetadataModelExportsToTargetRequest &request)
Definition DatabaseMigrationServiceWaiter.h:285
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelCreationCancelled
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelCreationsOutcome > WaitUntilMetadataModelCreationCancelled(const Model::DescribeMetadataModelCreationsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:231
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelExportedAsScript
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelExportsAsScriptOutcome > WaitUntilMetadataModelExportedAsScript(const Model::DescribeMetadataModelExportsAsScriptRequest &request)
Definition DatabaseMigrationServiceWaiter.h:258
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskDeleted
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskDeleted(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:417
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationInstanceAvailable
Aws::Utils::WaiterOutcome< Model::DescribeReplicationInstancesOutcome > WaitUntilReplicationInstanceAvailable(const Model::DescribeReplicationInstancesRequest &request)
Definition DatabaseMigrationServiceWaiter.h:339
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilMetadataModelConversionCancelled
Aws::Utils::WaiterOutcome< Model::DescribeMetadataModelConversionsOutcome > WaitUntilMetadataModelConversionCancelled(const Model::DescribeMetadataModelConversionsRequest &request)
Definition DatabaseMigrationServiceWaiter.h:150
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationTaskRunning
Aws::Utils::WaiterOutcome< Model::DescribeReplicationTasksOutcome > WaitUntilReplicationTaskRunning(const Model::DescribeReplicationTasksRequest &request)
Definition DatabaseMigrationServiceWaiter.h:553
Aws::DatabaseMigrationService::DatabaseMigrationServiceWaiter::WaitUntilReplicationInstanceDeleted
Aws::Utils::WaiterOutcome< Model::DescribeReplicationInstancesOutcome > WaitUntilReplicationInstanceDeleted(const Model::DescribeReplicationInstancesRequest &request)
Definition DatabaseMigrationServiceWaiter.h:395
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::DescribeMetadataModelCreationsOutcome
Aws::Utils::Outcome< DescribeMetadataModelCreationsResult, DatabaseMigrationServiceError > DescribeMetadataModelCreationsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:393
Aws::DatabaseMigrationService::Model::DescribeMetadataModelConversionsOutcome
Aws::Utils::Outcome< DescribeMetadataModelConversionsResult, DatabaseMigrationServiceError > DescribeMetadataModelConversionsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:392
Aws::DatabaseMigrationService::Model::DescribeEndpointsOutcome
Aws::Utils::Outcome< DescribeEndpointsResult, DatabaseMigrationServiceError > DescribeEndpointsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:375
Aws::DatabaseMigrationService::Model::DescribeMetadataModelImportsOutcome
Aws::Utils::Outcome< DescribeMetadataModelImportsResult, DatabaseMigrationServiceError > DescribeMetadataModelImportsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:398
Aws::DatabaseMigrationService::Model::DescribeReplicationTasksOutcome
Aws::Utils::Outcome< DescribeReplicationTasksResult, DatabaseMigrationServiceError > DescribeReplicationTasksOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:421
Aws::DatabaseMigrationService::Model::DescribeExtensionPackAssociationsOutcome
Aws::Utils::Outcome< DescribeExtensionPackAssociationsResult, DatabaseMigrationServiceError > DescribeExtensionPackAssociationsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:381
Aws::DatabaseMigrationService::Model::DescribeMetadataModelAssessmentsOutcome
Aws::Utils::Outcome< DescribeMetadataModelAssessmentsResult, DatabaseMigrationServiceError > DescribeMetadataModelAssessmentsOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:390
Aws::DatabaseMigrationService::Model::DescribeMetadataModelExportsAsScriptOutcome
Aws::Utils::Outcome< DescribeMetadataModelExportsAsScriptResult, DatabaseMigrationServiceError > DescribeMetadataModelExportsAsScriptOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:395
Aws::DatabaseMigrationService::Model::DescribeReplicationInstancesOutcome
Aws::Utils::Outcome< DescribeReplicationInstancesResult, DatabaseMigrationServiceError > DescribeReplicationInstancesOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:411
Aws::DatabaseMigrationService::Model::DescribeMetadataModelExportsToTargetOutcome
Aws::Utils::Outcome< DescribeMetadataModelExportsToTargetResult, DatabaseMigrationServiceError > DescribeMetadataModelExportsToTargetOutcome
Definition DatabaseMigrationServiceServiceClientModel.h:397
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