AWS SDK for C++

AWS SDK for C++ Version 1.11.778
Loading...
Searching...
No Matches
RDSWaiter.h
1
6#pragma once
7#include <aws/core/utils/Waiter.h>
8#include <aws/core/utils/memory/AWSMemory.h>
9#include <aws/rds/RDSClient.h>
10#include <aws/rds/model/DescribeDBClusterSnapshotsRequest.h>
11#include <aws/rds/model/DescribeDBClusterSnapshotsResult.h>
12#include <aws/rds/model/DescribeDBClustersRequest.h>
13#include <aws/rds/model/DescribeDBClustersResult.h>
14#include <aws/rds/model/DescribeDBInstancesRequest.h>
15#include <aws/rds/model/DescribeDBInstancesResult.h>
16#include <aws/rds/model/DescribeDBSnapshotsRequest.h>
17#include <aws/rds/model/DescribeDBSnapshotsResult.h>
18#include <aws/rds/model/DescribeTenantDatabasesRequest.h>
19#include <aws/rds/model/DescribeTenantDatabasesResult.h>
20
21#include <algorithm>
22
23namespace Aws {
24namespace RDS {
25
26template <typename DerivedClient = RDSClient>
27class RDSWaiter {
28 public:
29 Aws::Utils::WaiterOutcome<Model::DescribeDBClustersOutcome> WaitUntilDBClusterAvailable(const Model::DescribeDBClustersRequest& request) {
30 using OutcomeT = Model::DescribeDBClustersOutcome;
31 using RequestT = Model::DescribeDBClustersRequest;
32 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
33 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
34 "DBClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
35 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
36 if (!outcome.IsSuccess()) return false;
37 const auto& result = outcome.GetResult();
38 return std::all_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
39 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
40 }));
41 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
42 "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"),
43 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
44 if (!outcome.IsSuccess()) return false;
45 const auto& result = outcome.GetResult();
46 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
47 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
48 }));
49 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
50 "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
51 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
52 if (!outcome.IsSuccess()) return false;
53 const auto& result = outcome.GetResult();
54 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
55 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
56 }));
57 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
58 "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
59 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
60 if (!outcome.IsSuccess()) return false;
61 const auto& result = outcome.GetResult();
62 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
63 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
64 }));
65 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
66 "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"),
67 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
68 if (!outcome.IsSuccess()) return false;
69 const auto& result = outcome.GetResult();
70 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
71 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
72 }));
73 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
74 "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"),
75 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
76 if (!outcome.IsSuccess()) return false;
77 const auto& result = outcome.GetResult();
78 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
79 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
80 }));
81
82 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBClusters(req); };
83 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterAvailable");
84 return waiter.Wait(request);
85 }
86
87 Aws::Utils::WaiterOutcome<Model::DescribeDBClustersOutcome> WaitUntilDBClusterDeleted(const Model::DescribeDBClustersRequest& request) {
88 using OutcomeT = Model::DescribeDBClustersOutcome;
89 using RequestT = Model::DescribeDBClustersRequest;
90 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
91 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
92 "DBClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true,
93 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
94 if (!outcome.IsSuccess()) return false;
95 const auto& result = outcome.GetResult();
96 return (result.GetDBClusters().size() == 0) == expected.get<bool>();
97 }));
98 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("DBClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS,
99 Aws::String("DBClusterNotFoundFault")));
100 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
101 "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
102 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
103 if (!outcome.IsSuccess()) return false;
104 const auto& result = outcome.GetResult();
105 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
106 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
107 }));
108 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
109 "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
110 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
111 if (!outcome.IsSuccess()) return false;
112 const auto& result = outcome.GetResult();
113 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
114 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
115 }));
116 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
117 "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"),
118 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
119 if (!outcome.IsSuccess()) return false;
120 const auto& result = outcome.GetResult();
121 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
122 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
123 }));
124 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
125 "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"),
126 [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
127 if (!outcome.IsSuccess()) return false;
128 const auto& result = outcome.GetResult();
129 return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(),
130 [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get<Aws::String>(); });
131 }));
132
133 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBClusters(req); };
134 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterDeleted");
135 return waiter.Wait(request);
136 }
137
138 Aws::Utils::WaiterOutcome<Model::DescribeDBClusterSnapshotsOutcome> WaitUntilDBClusterSnapshotAvailable(
139 const Model::DescribeDBClusterSnapshotsRequest& request) {
140 using OutcomeT = Model::DescribeDBClusterSnapshotsOutcome;
141 using RequestT = Model::DescribeDBClusterSnapshotsRequest;
142 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
143 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
144 "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
145 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
146 if (!outcome.IsSuccess()) return false;
147 const auto& result = outcome.GetResult();
148 return std::all_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
149 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
150 }));
151 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
152 "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"),
153 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
154 if (!outcome.IsSuccess()) return false;
155 const auto& result = outcome.GetResult();
156 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
157 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
158 }));
159 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
160 "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
161 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
162 if (!outcome.IsSuccess()) return false;
163 const auto& result = outcome.GetResult();
164 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
165 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
166 }));
167 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
168 "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
169 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
170 if (!outcome.IsSuccess()) return false;
171 const auto& result = outcome.GetResult();
172 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
173 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
174 }));
175 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
176 "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"),
177 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
178 if (!outcome.IsSuccess()) return false;
179 const auto& result = outcome.GetResult();
180 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
181 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
182 }));
183 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
184 "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"),
185 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
186 if (!outcome.IsSuccess()) return false;
187 const auto& result = outcome.GetResult();
188 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
189 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
190 }));
191
192 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBClusterSnapshots(req); };
193 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterSnapshotAvailable");
194 return waiter.Wait(request);
195 }
196
197 Aws::Utils::WaiterOutcome<Model::DescribeDBClusterSnapshotsOutcome> WaitUntilDBClusterSnapshotDeleted(
198 const Model::DescribeDBClusterSnapshotsRequest& request) {
199 using OutcomeT = Model::DescribeDBClusterSnapshotsOutcome;
200 using RequestT = Model::DescribeDBClusterSnapshotsRequest;
201 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
202 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
203 "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true,
204 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
205 if (!outcome.IsSuccess()) return false;
206 const auto& result = outcome.GetResult();
207 return (result.GetDBClusterSnapshots().size() == 0) == expected.get<bool>();
208 }));
209 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
210 "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DBClusterSnapshotNotFoundFault")));
211 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
212 "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
213 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
214 if (!outcome.IsSuccess()) return false;
215 const auto& result = outcome.GetResult();
216 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
217 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
218 }));
219 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
220 "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
221 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
222 if (!outcome.IsSuccess()) return false;
223 const auto& result = outcome.GetResult();
224 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
225 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
226 }));
227 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
228 "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"),
229 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
230 if (!outcome.IsSuccess()) return false;
231 const auto& result = outcome.GetResult();
232 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
233 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
234 }));
235 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
236 "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"),
237 [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
238 if (!outcome.IsSuccess()) return false;
239 const auto& result = outcome.GetResult();
240 return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(),
241 [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
242 }));
243
244 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBClusterSnapshots(req); };
245 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterSnapshotDeleted");
246 return waiter.Wait(request);
247 }
248
249 Aws::Utils::WaiterOutcome<Model::DescribeDBInstancesOutcome> WaitUntilDBInstanceAvailable(
250 const Model::DescribeDBInstancesRequest& request) {
251 using OutcomeT = Model::DescribeDBInstancesOutcome;
252 using RequestT = Model::DescribeDBInstancesRequest;
253 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
254 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
255 "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
256 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
257 if (!outcome.IsSuccess()) return false;
258 const auto& result = outcome.GetResult();
259 return std::all_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
260 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
261 }));
262 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
263 "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"),
264 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
265 if (!outcome.IsSuccess()) return false;
266 const auto& result = outcome.GetResult();
267 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
268 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
269 }));
270 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
271 "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
272 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
273 if (!outcome.IsSuccess()) return false;
274 const auto& result = outcome.GetResult();
275 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
276 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
277 }));
278 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
279 "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
280 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
281 if (!outcome.IsSuccess()) return false;
282 const auto& result = outcome.GetResult();
283 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
284 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
285 }));
286 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
287 "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"),
288 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
289 if (!outcome.IsSuccess()) return false;
290 const auto& result = outcome.GetResult();
291 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
292 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
293 }));
294 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
295 "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"),
296 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
297 if (!outcome.IsSuccess()) return false;
298 const auto& result = outcome.GetResult();
299 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
300 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
301 }));
302
303 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBInstances(req); };
304 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBInstanceAvailable");
305 return waiter.Wait(request);
306 }
307
308 Aws::Utils::WaiterOutcome<Model::DescribeDBInstancesOutcome> WaitUntilDBInstanceDeleted(
309 const Model::DescribeDBInstancesRequest& request) {
310 using OutcomeT = Model::DescribeDBInstancesOutcome;
311 using RequestT = Model::DescribeDBInstancesRequest;
312 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
313 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
314 "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true,
315 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
316 if (!outcome.IsSuccess()) return false;
317 const auto& result = outcome.GetResult();
318 return (result.GetDBInstances().size() == 0) == expected.get<bool>();
319 }));
320 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS,
321 Aws::String("DBInstanceNotFound")));
322 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
323 "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
324 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
325 if (!outcome.IsSuccess()) return false;
326 const auto& result = outcome.GetResult();
327 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
328 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
329 }));
330 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
331 "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
332 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
333 if (!outcome.IsSuccess()) return false;
334 const auto& result = outcome.GetResult();
335 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
336 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
337 }));
338 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
339 "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"),
340 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
341 if (!outcome.IsSuccess()) return false;
342 const auto& result = outcome.GetResult();
343 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
344 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
345 }));
346 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
347 "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"),
348 [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
349 if (!outcome.IsSuccess()) return false;
350 const auto& result = outcome.GetResult();
351 return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(),
352 [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get<Aws::String>(); });
353 }));
354
355 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBInstances(req); };
356 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBInstanceDeleted");
357 return waiter.Wait(request);
358 }
359
360 Aws::Utils::WaiterOutcome<Model::DescribeDBSnapshotsOutcome> WaitUntilDBSnapshotAvailable(
361 const Model::DescribeDBSnapshotsRequest& request) {
362 using OutcomeT = Model::DescribeDBSnapshotsOutcome;
363 using RequestT = Model::DescribeDBSnapshotsRequest;
364 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
365 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
366 "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
367 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
368 if (!outcome.IsSuccess()) return false;
369 const auto& result = outcome.GetResult();
370 return std::all_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
371 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
372 }));
373 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
374 "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"),
375 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
376 if (!outcome.IsSuccess()) return false;
377 const auto& result = outcome.GetResult();
378 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
379 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
380 }));
381 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
382 "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"),
383 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
384 if (!outcome.IsSuccess()) return false;
385 const auto& result = outcome.GetResult();
386 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
387 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
388 }));
389 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
390 "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"),
391 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
392 if (!outcome.IsSuccess()) return false;
393 const auto& result = outcome.GetResult();
394 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
395 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
396 }));
397 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
398 "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"),
399 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
400 if (!outcome.IsSuccess()) return false;
401 const auto& result = outcome.GetResult();
402 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
403 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
404 }));
405 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
406 "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"),
407 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
408 if (!outcome.IsSuccess()) return false;
409 const auto& result = outcome.GetResult();
410 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
411 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
412 }));
413
414 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBSnapshots(req); };
415 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBSnapshotAvailable");
416 return waiter.Wait(request);
417 }
418
419 Aws::Utils::WaiterOutcome<Model::DescribeDBSnapshotsOutcome> WaitUntilDBSnapshotDeleted(
420 const Model::DescribeDBSnapshotsRequest& request) {
421 using OutcomeT = Model::DescribeDBSnapshotsOutcome;
422 using RequestT = Model::DescribeDBSnapshotsRequest;
423 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
424 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
425 "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true,
426 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
427 if (!outcome.IsSuccess()) return false;
428 const auto& result = outcome.GetResult();
429 return (result.GetDBSnapshots().size() == 0) == expected.get<bool>();
430 }));
431 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS,
432 Aws::String("DBSnapshotNotFound")));
433 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
434 "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"),
435 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
436 if (!outcome.IsSuccess()) return false;
437 const auto& result = outcome.GetResult();
438 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
439 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
440 }));
441 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
442 "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"),
443 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
444 if (!outcome.IsSuccess()) return false;
445 const auto& result = outcome.GetResult();
446 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
447 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
448 }));
449 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
450 "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"),
451 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
452 if (!outcome.IsSuccess()) return false;
453 const auto& result = outcome.GetResult();
454 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
455 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
456 }));
457 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
458 "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"),
459 [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
460 if (!outcome.IsSuccess()) return false;
461 const auto& result = outcome.GetResult();
462 return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(),
463 [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get<Aws::String>(); });
464 }));
465
466 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeDBSnapshots(req); };
467 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBSnapshotDeleted");
468 return waiter.Wait(request);
469 }
470
471 Aws::Utils::WaiterOutcome<Model::DescribeTenantDatabasesOutcome> WaitUntilTenantDatabaseAvailable(
472 const Model::DescribeTenantDatabasesRequest& request) {
473 using OutcomeT = Model::DescribeTenantDatabasesOutcome;
474 using RequestT = Model::DescribeTenantDatabasesRequest;
475 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
476 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
477 "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"),
478 [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
479 if (!outcome.IsSuccess()) return false;
480 const auto& result = outcome.GetResult();
481 return std::all_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(),
482 [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get<Aws::String>(); });
483 }));
484 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
485 "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"),
486 [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
487 if (!outcome.IsSuccess()) return false;
488 const auto& result = outcome.GetResult();
489 return std::any_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(),
490 [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get<Aws::String>(); });
491 }));
492 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
493 "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"),
494 [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
495 if (!outcome.IsSuccess()) return false;
496 const auto& result = outcome.GetResult();
497 return std::any_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(),
498 [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get<Aws::String>(); });
499 }));
500 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
501 "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"),
502 [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
503 if (!outcome.IsSuccess()) return false;
504 const auto& result = outcome.GetResult();
505 return std::any_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(),
506 [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get<Aws::String>(); });
507 }));
508
509 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeTenantDatabases(req); };
510 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilTenantDatabaseAvailable");
511 return waiter.Wait(request);
512 }
513
514 Aws::Utils::WaiterOutcome<Model::DescribeTenantDatabasesOutcome> WaitUntilTenantDatabaseDeleted(
515 const Model::DescribeTenantDatabasesRequest& request) {
516 using OutcomeT = Model::DescribeTenantDatabasesOutcome;
517 using RequestT = Model::DescribeTenantDatabasesRequest;
518 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
519 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
520 "TenantDatabaseDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true,
521 [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
522 if (!outcome.IsSuccess()) return false;
523 const auto& result = outcome.GetResult();
524 return (result.GetTenantDatabases().size() == 0) == expected.get<bool>();
525 }));
526 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
527 "TenantDatabaseDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DBInstanceNotFoundFault")));
528
529 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeTenantDatabases(req); };
530 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(30, 60, std::move(acceptors), operation, "WaitUntilTenantDatabaseDeleted");
531 return waiter.Wait(request);
532 }
533};
534} // namespace RDS
535} // namespace Aws
Aws::RDS::RDSWaiter::WaitUntilDBSnapshotDeleted
Aws::Utils::WaiterOutcome< Model::DescribeDBSnapshotsOutcome > WaitUntilDBSnapshotDeleted(const Model::DescribeDBSnapshotsRequest &request)
Definition RDSWaiter.h:419
Aws::RDS::RDSWaiter::WaitUntilDBClusterSnapshotDeleted
Aws::Utils::WaiterOutcome< Model::DescribeDBClusterSnapshotsOutcome > WaitUntilDBClusterSnapshotDeleted(const Model::DescribeDBClusterSnapshotsRequest &request)
Definition RDSWaiter.h:197
Aws::RDS::RDSWaiter::WaitUntilDBInstanceAvailable
Aws::Utils::WaiterOutcome< Model::DescribeDBInstancesOutcome > WaitUntilDBInstanceAvailable(const Model::DescribeDBInstancesRequest &request)
Definition RDSWaiter.h:249
Aws::RDS::RDSWaiter::WaitUntilDBClusterAvailable
Aws::Utils::WaiterOutcome< Model::DescribeDBClustersOutcome > WaitUntilDBClusterAvailable(const Model::DescribeDBClustersRequest &request)
Definition RDSWaiter.h:29
Aws::RDS::RDSWaiter::WaitUntilDBClusterSnapshotAvailable
Aws::Utils::WaiterOutcome< Model::DescribeDBClusterSnapshotsOutcome > WaitUntilDBClusterSnapshotAvailable(const Model::DescribeDBClusterSnapshotsRequest &request)
Definition RDSWaiter.h:138
Aws::RDS::RDSWaiter::WaitUntilTenantDatabaseDeleted
Aws::Utils::WaiterOutcome< Model::DescribeTenantDatabasesOutcome > WaitUntilTenantDatabaseDeleted(const Model::DescribeTenantDatabasesRequest &request)
Definition RDSWaiter.h:514
Aws::RDS::RDSWaiter::WaitUntilDBClusterDeleted
Aws::Utils::WaiterOutcome< Model::DescribeDBClustersOutcome > WaitUntilDBClusterDeleted(const Model::DescribeDBClustersRequest &request)
Definition RDSWaiter.h:87
Aws::RDS::RDSWaiter::WaitUntilDBSnapshotAvailable
Aws::Utils::WaiterOutcome< Model::DescribeDBSnapshotsOutcome > WaitUntilDBSnapshotAvailable(const Model::DescribeDBSnapshotsRequest &request)
Definition RDSWaiter.h:360
Aws::RDS::RDSWaiter::WaitUntilTenantDatabaseAvailable
Aws::Utils::WaiterOutcome< Model::DescribeTenantDatabasesOutcome > WaitUntilTenantDatabaseAvailable(const Model::DescribeTenantDatabasesRequest &request)
Definition RDSWaiter.h:471
Aws::RDS::RDSWaiter::WaitUntilDBInstanceDeleted
Aws::Utils::WaiterOutcome< Model::DescribeDBInstancesOutcome > WaitUntilDBInstanceDeleted(const Model::DescribeDBInstancesRequest &request)
Definition RDSWaiter.h:308
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::RDS::Model::DescribeDBSnapshotsOutcome
Aws::Utils::Outcome< DescribeDBSnapshotsResult, RDSError > DescribeDBSnapshotsOutcome
Definition RDSServiceClientModel.h:492
Aws::RDS::Model::DescribeDBClustersOutcome
Aws::Utils::Outcome< DescribeDBClustersResult, RDSError > DescribeDBClustersOutcome
Definition RDSServiceClientModel.h:475
Aws::RDS::Model::DescribeDBClusterSnapshotsOutcome
Aws::Utils::Outcome< DescribeDBClusterSnapshotsResult, RDSError > DescribeDBClusterSnapshotsOutcome
Definition RDSServiceClientModel.h:474
Aws::RDS::Model::DescribeTenantDatabasesOutcome
Aws::Utils::Outcome< DescribeTenantDatabasesResult, RDSError > DescribeTenantDatabasesOutcome
Definition RDSServiceClientModel.h:509
Aws::RDS::Model::DescribeDBInstancesOutcome
Aws::Utils::Outcome< DescribeDBInstancesResult, RDSError > DescribeDBInstancesOutcome
Definition RDSServiceClientModel.h:478
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