1#include <test/jtx/Account.h>
2#include <test/jtx/Env.h>
3#include <test/jtx/amount.h>
4#include <test/jtx/envconfig.h>
5#include <test/jtx/noop.h>
7#include <xrpld/app/ledger/LedgerMaster.h>
8#include <xrpld/app/main/Application.h>
9#include <xrpld/app/main/NodeStoreScheduler.h>
10#include <xrpld/app/misc/SHAMapStore.h>
11#include <xrpld/app/rdb/backend/SQLiteDatabase.h>
12#include <xrpld/core/Config.h>
14#include <xrpl/basics/ByteUtilities.h>
15#include <xrpl/basics/Log.h>
16#include <xrpl/basics/base_uint.h>
17#include <xrpl/beast/unit_test/suite.h>
18#include <xrpl/beast/utility/Journal.h>
19#include <xrpl/config/BasicConfig.h>
20#include <xrpl/config/Constants.h>
21#include <xrpl/core/JobQueue.h>
22#include <xrpl/json/json_value.h>
23#include <xrpl/nodestore/Backend.h>
24#include <xrpl/nodestore/Manager.h>
25#include <xrpl/nodestore/detail/DatabaseRotatingImp.h>
26#include <xrpl/protocol/ErrorCodes.h>
27#include <xrpl/protocol/LedgerHeader.h>
28#include <xrpl/protocol/Protocol.h>
29#include <xrpl/protocol/XRPAmount.h>
30#include <xrpl/protocol/jss.h>
31#include <xrpl/server/NetworkOPs.h>
75 static constexpr char const*
kFullWait =
"Waiting 1000ms for node to stabilize";
76 static constexpr char const*
kShortWait =
"Waiting 100ms for node to stabilize";
86 static constexpr char const*
kRotating =
"rotating";
87 static constexpr char const*
kFinished =
"finished rotation";
88 static constexpr char const*
kExpired =
"unable to make progress";
136 owner_.messages_.emplace_back(level, text);
138 owner_.cond_.notify_all();
153 return (!severity || message.first == *severity) &&
154 message.second.find(text) != std::string::npos;
208 return cond_.wait_for(
209 lock, timeout, [&] {
return countLocked(severity, text) >= expected; });
219 return waitFor(std::nullopt, text, timeout, expected);
269 json[jss::result][jss::ledger][jss::ledger_index] == ledgerID;
270 if (!good || !checkDB)
273 auto const seq =
json[jss::result][jss::ledger_index].asUInt();
292 auto const& ledger =
json[jss::result][jss::ledger];
293 return outHash == ledger[jss::ledger_hash].asString() && outSeq == seq &&
294 outParentHash == ledger[jss::parent_hash].asString() &&
295 outDrops == ledger[jss::total_coins].asString() &&
296 outCloseTime == ledger[jss::close_time].asUInt() &&
297 outParentCloseTime == ledger[jss::parent_close_time].asUInt() &&
298 outCloseTimeResolution == ledger[jss::close_time_resolution].asUInt() &&
299 outCloseFlags == ledger[jss::close_flags].asUInt() &&
300 outAccountHash == ledger[jss::account_hash].asString() &&
301 outTxHash == ledger[jss::transaction_hash].asString();
310 return json.isMember(jss::result) &&
json[jss::result][jss::error] ==
token &&
311 json[jss::result][jss::error_code] == error &&
312 json[jss::result][jss::error_message] == message;
319 json.isMember(jss::result) &&
json[jss::result].isMember(jss::ledger) &&
320 json[jss::result][jss::ledger].isMember(jss::ledger_hash) &&
321 json[jss::result][jss::ledger][jss::ledger_hash].isString());
322 return json[jss::result][jss::ledger][jss::ledger_hash].asString();
328 auto const [actualRows, actualFirst, actualLast] =
331 BEAST_EXPECT(actualRows == rows);
332 BEAST_EXPECT(actualFirst == first);
333 BEAST_EXPECT(actualLast == first + rows - 1);
357 [[nodiscard]]
static bool
418 for (
int extraCloses = 0;; ++extraCloses)
422 if (store.getLastRotated() != 0 || extraCloses == maxExtraCloses)
424 if (extraCloses != 0)
426 log <<
"initializeStore: the store needed " << extraCloses
427 <<
" extra ledger close(s) to pick up a validated ledger. "
428 "SHAMapStoreImp::run() dropped the notification for the "
429 "first one; see the comment on initializeStore()."
441 using namespace std::chrono_literals;
447 BEAST_EXPECT(!store.getLastRotated());
452 auto const ledger = env.
rpc(
"ledger",
"validated");
455 BEAST_EXPECT(store.getLastRotated() == ledgerSeq - 1);
507 BEAST_EXPECTS(result == expected, result.value_or(
"<accepted>"));
514 BEAST_EXPECTS(!result, result.value_or(
""));
550 using namespace std::chrono_literals;
602 while (!lm.haveLedger(maxSeq) && --iterations > 0)
606 if (!BEAST_EXPECTS(lm.haveLedger(maxSeq),
std::to_string(maxSeq)))
613 lm.clearLedger(maxSeq);
614 if (!BEAST_EXPECT(!lm.haveLedger(maxSeq)))
623 netOPs.setMode(modeAfterClose);
631 if (!BEAST_EXPECT(!store.rendezvous(1s)))
676 using namespace std::chrono_literals;
682 auto const alice =
Account(
"alice");
691 auto const closeOne = [&] ->
bool {
702 LedgerIndex const firstRotated = store.getLastRotated();
703 if (!BEAST_EXPECT(firstRotated))
705 while (store.getLastRotated() == firstRotated)
762 auto const published = lm.getPublishedLedger();
764 published && published->header().seq >= parked.
validated,
768 if (!BEAST_EXPECT(
log.waitFor(
kRotating, 10s, rotationsBefore + 1)))
777 if (!BEAST_EXPECT(!lm.haveLedger(parked.
gap)))
783 if (!BEAST_EXPECT(!store.rendezvous(1500ms)))
824 "online_delete must not be less than ledger_history (currently " +
838 auto const tooFewWaiting =
873 using namespace std::chrono_literals;
889 auto ledgerTmp = env.
rpc(
"ledger",
"0");
893 BEAST_EXPECT(
goodLedger(env, ledgers[1],
"1"));
896 BEAST_EXPECT(
goodLedger(env, ledgers[2],
"2"));
898 ledgerTmp = env.
rpc(
"ledger",
"current");
899 BEAST_EXPECT(
goodLedger(env, ledgerTmp,
"3"));
901 ledgerTmp = env.
rpc(
"ledger",
"4");
904 ledgerTmp = env.
rpc(
"ledger",
"100");
908 auto lastRotated = firstSeq - 1;
915 ledgerTmp = env.
rpc(
"ledger",
"current");
918 BEAST_EXPECT(store.getLastRotated() == lastRotated);
936 auto const ledger = env.
rpc(
"ledger",
"current");
943 lastRotated = store.getLastRotated();
944 BEAST_EXPECT(lastRotated == 11);
952 for (
auto i = lastRotated - 1; i < lastRotated +
kDeleteInterval - 1; ++i)
956 ledgerTmp = env.
rpc(
"ledger",
"current");
961 store.getLastRotated() == lastRotated || i == lastRotated +
kDeleteInterval - 2);
979 testcase(
"automatic online_delete");
981 using namespace std::chrono_literals;
987 auto lastRotated = ledgerSeq - 1;
988 BEAST_EXPECT(store.getLastRotated() == lastRotated);
989 BEAST_EXPECT(lastRotated != 2);
993 auto const canDelete = env.
rpc(
"can_delete");
994 BEAST_EXPECT(
bad(canDelete,
"notEnabled",
RpcNotEnabled,
"Not enabled in configuration."));
1001 auto const ledger = env.
rpc(
"ledger",
"validated");
1010 BEAST_EXPECT(lastRotated == store.getLastRotated());
1016 auto const ledger = env.
rpc(
"ledger",
"validated");
1022 ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
1023 BEAST_EXPECT(lastRotated != store.getLastRotated());
1025 lastRotated = store.getLastRotated();
1032 auto const ledger = env.
rpc(
"ledger",
"validated");
1039 BEAST_EXPECT(lastRotated != store.getLastRotated());
1045 testcase(
"online_delete with advisory_delete");
1046 using namespace jtx;
1047 using namespace std::chrono_literals;
1054 auto lastRotated = ledgerSeq - 1;
1055 BEAST_EXPECT(store.getLastRotated() == lastRotated);
1056 BEAST_EXPECT(lastRotated != 2);
1058 auto canDelete = env.
rpc(
"can_delete");
1060 BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == 0);
1062 canDelete = env.
rpc(
"can_delete",
"never");
1064 BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == 0);
1067 for (; ledgerSeq < firstBatch; ++ledgerSeq)
1071 auto const ledger = env.
rpc(
"ledger",
"validated");
1078 BEAST_EXPECT(lastRotated == store.getLastRotated());
1083 BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == ledgerSeq + (
kDeleteInterval / 2));
1088 BEAST_EXPECT(store.getLastRotated() == lastRotated);
1094 auto const ledger = env.
rpc(
"ledger",
"validated");
1100 ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
1102 BEAST_EXPECT(store.getLastRotated() == ledgerSeq - 1);
1103 lastRotated = ledgerSeq - 1;
1110 auto const ledger = env.
rpc(
"ledger",
"validated");
1116 BEAST_EXPECT(store.getLastRotated() == lastRotated);
1122 auto const ledger = env.
rpc(
"ledger",
"validated");
1128 ledgerCheck(env, ledgerSeq - firstBatch, firstBatch);
1130 BEAST_EXPECT(store.getLastRotated() == ledgerSeq - 1);
1131 lastRotated = ledgerSeq - 1;
1134 canDelete = env.
rpc(
"can_delete",
"always");
1144 auto const ledger = env.
rpc(
"ledger",
"validated");
1150 BEAST_EXPECT(store.getLastRotated() == lastRotated);
1156 auto const ledger = env.
rpc(
"ledger",
"validated");
1162 ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
1164 BEAST_EXPECT(store.getLastRotated() == ledgerSeq - 1);
1165 lastRotated = ledgerSeq - 1;
1168 canDelete = env.
rpc(
"can_delete",
"now");
1170 BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == ledgerSeq - 1);
1177 auto const ledger = env.
rpc(
"ledger",
"validated");
1183 BEAST_EXPECT(store.getLastRotated() == lastRotated);
1189 auto const ledger = env.
rpc(
"ledger",
"validated");
1195 ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
1197 BEAST_EXPECT(store.getLastRotated() == ledgerSeq - 1);
1198 lastRotated = ledgerSeq - 1;
1207 if (!BEAST_EXPECT(
path.size()))
1228 testcase(
"rotate with lock contention");
1230 using namespace jtx;
1262 static constexpr int kReadThreads = 4;
1266 std::move(writableBackend),
1267 std::move(archiveBackend),
1273 using namespace std::chrono_literals;
1280 BEAST_EXPECT(writableName ==
"1");
1281 BEAST_EXPECT(archiveName ==
"write");
1284 BEAST_EXPECT(dbr->getName() ==
"1");
1287 dbr->rotate(std::move(newBackend), cb);
1289 BEAST_EXPECT(threadNum == 1);
1290 BEAST_EXPECT(dbr->getName() ==
"1");
1296 BEAST_EXPECT(writableName ==
"3");
1297 BEAST_EXPECT(archiveName ==
"2");
1300 BEAST_EXPECT(dbr->getName() ==
"3");
1302 auto const cbReentrant = [&](
std::string const& writableName,
1304 BEAST_EXPECT(writableName ==
"2");
1305 BEAST_EXPECT(archiveName ==
"1");
1308 dbr->rotate(std::move(newBackend), cb);
1311 dbr->rotate(std::move(newBackend), cbReentrant);
1314 BEAST_EXPECT(threadNum == 3);
1315 BEAST_EXPECT(dbr->getName() ==
"3");
1325 testcase(
"Wait for ledger gaps to fill in");
1331 auto failureMessage = [&](
char const* label,
auto expected,
auto actual) {
1333 ss << label <<
": Expected: " << expected <<
", Got: " << actual;
1337 auto const alice =
Account(
"alice");
1359 if (!BEAST_EXPECT(extraCloses.has_value()))
1364 lastRotated >= minSeq && lastRotated <= maxSeq,
std::to_string(lastRotated)))
1369 BEAST_EXPECTS(maxSeq == 3 + *extraCloses,
std::to_string(maxSeq));
1371 initialRange << minSeq <<
"-" << maxSeq;
1372 BEAST_EXPECTS(lm.getCompleteLedgers() == initialRange.
str(), lm.getCompleteLedgers());
1373 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == 0);
1378 if (minSeq + 1 <= maxSeq - 1)
1380 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == 0);
1382 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 1, maxSeq + 1) == 2);
1383 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 2, maxSeq - 2) == 2);
1384 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 2, maxSeq + 2) == 2);
1386 auto expectedRange =
1389 expectedRange << minSeq;
1390 auto lastDelete = minSeq - 1;
1391 for (
auto const deleteSeq : deleteSeqs)
1393 if (deleteSeq <= lastDelete)
1395 expectedRange <<
"-" << (deleteSeq - 1);
1396 if (deleteSeq + 1 <= maxSeq)
1397 expectedRange <<
"," << (deleteSeq + 1);
1398 lastDelete = deleteSeq;
1400 if (lastDelete + 1 < maxSeq)
1402 expectedRange <<
"-" << maxSeq;
1404 return expectedRange.
str();
1407 auto const deleteLedgerSeq =
1408 [&lm, &store, &netOPs, &minSeq, &lastRotated, &expectedRange, &failureMessage,
this](
1412 using namespace std::chrono_literals;
1421 while (!lm.haveLedger(deleteSeq) && --iterations > 0)
1430 if (!BEAST_EXPECT(lm.haveLedger(deleteSeq)))
1438 lm.clearLedger(deleteSeq);
1439 deleteSeqs.push_back(deleteSeq);
1440 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1444 lm.getCompleteLedgers() == expectedRange(minSeq, deleteSeqs, maxSeq),
1447 expectedRange(minSeq, deleteSeqs, maxSeq),
1448 lm.getCompleteLedgers()));
1449 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == deleteSeqs.size());
1451 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1461 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1465 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1467 BEAST_EXPECT(!store.rendezvous(10ms));
1472 store.getLastRotated() == lastRotated,
1473 failureMessage(
"lastRotated", lastRotated, store.getLastRotated()));
1475 lm.getCompleteLedgers() == expectedRange(minSeq, deleteSeqs, maxSeq),
1478 expectedRange(minSeq, deleteSeqs, maxSeq),
1479 lm.getCompleteLedgers()));
1489 for (
int t = 0; t < 3; ++t)
1500 using namespace std::chrono_literals;
1505 LedgerIndex const deleteSeq = deleteLedgerSeq(env, maxSeq, deleteSeqs);
1506 if (!BEAST_EXPECT(deleteSeq > 0))
1508 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1521 store.getLastRotated() == lastRotated,
1522 failureMessage(
"lastRotated", lastRotated, store.getLastRotated()));
1524 lm.getCompleteLedgers() == expectedRange(minSeq, deleteSeqs, maxSeq),
1527 expectedRange(minSeq, deleteSeqs, maxSeq),
1528 lm.getCompleteLedgers()));
1531 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1542 BEAST_EXPECT(!store.rendezvous(1s));
1550 store.getLastRotated() == lastRotated,
1551 failureMessage(
"lastRotated", lastRotated, store.getLastRotated()));
1553 lm.getCompleteLedgers() == expectedRange(minSeq, deleteSeqs, maxSeq),
1556 expectedRange(minSeq, deleteSeqs, maxSeq),
1557 lm.getCompleteLedgers()));
1564 LedgerIndex const deleteSeq = deleteLedgerSeq(env, maxSeq, deleteSeqs);
1565 if (!BEAST_EXPECT(deleteSeq > 0))
1567 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1575 for (
int l = 0; l < 5; ++l)
1581 store.getLastRotated() == lastRotated,
1582 failureMessage(
"lastRotated", lastRotated, store.getLastRotated()));
1584 lm.getCompleteLedgers() == expectedRange(minSeq, deleteSeqs, maxSeq),
1587 expectedRange(minSeq, deleteSeqs, maxSeq),
1588 lm.getCompleteLedgers()));
1589 if (!BEAST_EXPECT(!lm.haveLedger(deleteSeq)))
1597 BEAST_EXPECT(!store.rendezvous(1s));
1600 lm.setLedgerRangePresent(deleteSeq, deleteSeq);
1601 BEAST_EXPECT(deleteSeqs.back() == deleteSeq);
1602 deleteSeqs.pop_back();
1607 minSeq = lastRotated;
1608 while (deleteSeqs.front() < minSeq)
1610 deleteSeqs.erase(deleteSeqs.begin());
1612 lastRotated = deleteSeq + 1;
1617 env.
closed()->header().seq == maxSeq,
1618 failureMessage(
"maxSeq", maxSeq, env.
closed()->header().seq));
1620 store.getLastRotated() == lastRotated,
1621 failureMessage(
"lastRotated", lastRotated, store.getLastRotated()));
1623 auto const expected = expectedRange(minSeq, deleteSeqs, maxSeq);
1625 lm.getCompleteLedgers() == expected,
1626 failureMessage(
"CompleteLedgers", expected, lm.getCompleteLedgers()));
1628 BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == deleteSeqs.size());
1634 if (minSeq + 1 <= maxSeq - 1)
1637 lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == deleteSeqs.size());
1641 BEAST_EXPECTS(
false, failureMessage(
"range collapsed", minSeq, maxSeq));
1644 lm.missingFromCompleteLedgerRange(minSeq - 1, maxSeq + 1) == deleteSeqs.size() + 2);
1646 lm.missingFromCompleteLedgerRange(minSeq - 2, maxSeq - 2) == deleteSeqs.size() + 2);
1648 lm.missingFromCompleteLedgerRange(minSeq + 2, maxSeq + 2) == deleteSeqs.size() + 2);
1660 testcase(
"healthWait server state");
1662 using namespace std::chrono_literals;
1667 auto*
const log = logs.get();
1690 BEAST_EXPECT(!store.rendezvous(10ms));
1694 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
1705 auto const closeTime = env.
now();
1709 BEAST_EXPECT(!store.rendezvous(1500ms));
1711 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
1718 store.getLastRotated() == parked->validated,
std::to_string(store.getLastRotated()));
1724 testcase(
"healthWait gap wait levels");
1726 using namespace std::chrono_literals;
1731 auto*
const log = logs.get();
1746 BEAST_EXPECT(lm.haveLedger(parked->validated));
1747 BEAST_EXPECT(!lm.haveLedger(parked->gap));
1752 BEAST_EXPECT(!store.rendezvous(10ms));
1760 lm.setLedgerRangePresent(parked->gap, parked->gap);
1761 lm.clearLedger(parked->validated);
1762 BEAST_EXPECT(lm.haveLedger(parked->gap));
1763 BEAST_EXPECT(!lm.haveLedger(parked->validated));
1765 BEAST_EXPECT(!store.rendezvous(10ms));
1767 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
1770 lm.setLedgerRangePresent(parked->validated, parked->validated);
1773 store.getLastRotated() == parked->validated,
std::to_string(store.getLastRotated()));
1779 testcase(
"healthWait disconnected");
1781 using namespace std::chrono_literals;
1795 BEAST_EXPECT(!store.rendezvous(1500ms));
1797 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
1808 store.getLastRotated() == parked->validated,
std::to_string(store.getLastRotated()));
1810 BEAST_EXPECT(!lm.haveLedger(parked->gap));
1839 BEAST_EXPECT(store.rendezvous());
1841 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
1855 testcase(
"healthWait circuit breaker mid-rotation");
1860 auto*
const log = logs.get();
1878 BEAST_EXPECT(!lm.haveLedger(parked->gap));
1886 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
1889 BEAST_EXPECT(!lm.haveLedger(parked->gap));
1895 testcase(
"healthWait stop mid-rotation");
1900 auto*
const log = logs.get();
1921 store.getLastRotated() == parked->lastRotated,
std::to_string(store.getLastRotated()));
Abstraction for the underlying message destination.
LogOs< char > log
Logging output stream.
TestcaseT testcase
Memberspace for declaring test cases.
virtual Config & config()=0
Section & section(std::string const &name)
Returns the section with the given name.
std::uint32_t ledgerHistory
int getValueFor(SizedItem item, std::optional< std::size_t > node=std::nullopt) const
Retrieve the default value for the item at the specified node size.
void rendezvous()
Block until no jobs running.
Logs(beast::Severity level)
A node_store::Scheduler which uses the JobQueue.
virtual std::size_t getAccountTransactionCount()=0
getAccountTransactionCount Returns the number of account transactions.
virtual std::size_t getTransactionCount()=0
getTransactionCount Returns the number of transactions.
virtual CountMinMax getLedgerCountMinMax()=0
getLedgerCountMinMax Returns the minimum ledger sequence, maximum ledger sequence and total number of...
virtual std::optional< LedgerHeader > getLedgerInfoByIndex(LedgerIndex ledgerSeq)=0
getLedgerInfoByIndex Returns a ledger by its sequence.
class to create database, launch online delete thread, and related SQLite database
virtual bool rendezvous(std::optional< std::chrono::milliseconds > const &timeout={}) const =0
Holds a collection of configuration values.
void set(std::string const &key, std::string const &value)
Set a key/value pair.
virtual JobQueue & getJobQueue()=0
virtual RelationalDatabase & getRelationalDatabase()=0
virtual beast::Journal getJournal(std::string const &name)=0
virtual NetworkOPs & getOPs()=0
virtual SHAMapStore & getSHAMapStore()=0
virtual LedgerMaster & getLedgerMaster()=0
virtual std::unique_ptr< Backend > makeBackend(Section const ¶meters, std::size_t burstSize, Scheduler &scheduler, beast::Journal journal)=0
Create a backend.
static Manager & instance()
Returns the instance of the manager singleton.
void write(beast::Severity level, std::string const &text) override
Write text to the sink at the specified severity.
Sink(beast::Severity threshold, StoreLogs &owner)
void threshold(beast::Severity) override
Set the minimum severity this sink will report.
void writeAlways(beast::Severity level, std::string const &text) override
Bypass filter and write text to the sink at the specified severity.
std::size_t countLocked(std::optional< beast::Severity > severity, std::string const &text) const
bool waitFor(std::string const &text, std::chrono::milliseconds timeout, std::size_t expected=1)
std::unique_ptr< beast::Journal::Sink > makeSink(std::string const &partition, beast::Severity) override
bool waitFor(std::optional< beast::Severity > severity, std::string const &text, std::chrono::milliseconds timeout, std::size_t expected=1)
std::vector< std::pair< beast::Severity, std::string > > messages_
std::condition_variable cond_
std::size_t count(std::string const &text) const
std::size_t count(beast::Severity severity, std::string const &text) const
void testHealthWaitDisconnected()
void testHealthWaitExpiredMidRotation()
static auto onlineDelete(std::unique_ptr< Config > cfg)
static auto advisoryDelete(std::unique_ptr< Config > cfg)
std::optional< Parked > parkInHealthWait(jtx::Env &env, bool createGap, OperatingMode modeAfterClose)
std::optional< int > initializeStore(jtx::Env &env, int const maxExtraCloses=3)
void testHealthWaitStop()
static constexpr char const * kShortWait
static constexpr int kMinDeleteInterval
static constexpr int kDeleteInterval
std::unique_ptr< node_store::Backend > makeBackendRotating(jtx::Env &env, NodeStoreScheduler &scheduler, std::string path)
static constexpr char const * kExpired
void testHealthWaitGapLevels()
static bool bad(json::Value const &json, std::string const &token, ErrorCodeI error, std::string const &message)
void ledgerCheck(jtx::Env &env, int const rows, int const first)
void expectConfigAccepted(std::function< void(Config &)> const &tweak)
void accountTransactionCheck(jtx::Env &env, int const rows)
void run() override
Runs the suite.
void expectConfigRejected(std::string const &expected, std::function< void(Config &)> const &tweak)
static constexpr int kMinWaitingLedgers
static auto slowOnlineDelete(std::unique_ptr< Config > cfg)
void testHealthWaitState()
static bool syncStore(jtx::Env &env)
std::optional< std::string > storeConfigResult(std::function< void(Config &)> const &tweak)
void transactionCheck(jtx::Env &env, int const rows)
static constexpr char const * kFullWait
int waitForReady(jtx::Env &env)
std::string getHash(json::Value const &json)
std::optional< Parked > parkMidRotation(jtx::Env &env, StoreLogs &log)
void testHealthWaitStopMidRotation()
static constexpr char const * kRotating
static constexpr char const * kFinished
static bool goodLedger(jtx::Env &env, json::Value const &json, std::string ledgerID, bool checkDB=false)
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
std::shared_ptr< ReadView const > closed()
Returns the last closed ledger.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
ManualTimeKeeper & timeKeeper()
NetClock::time_point now()
Returns the current network time.
Severity
Severity level / threshold of a Journal message.
JSON (JavaScript Object Notation).
bool containsError(json::Value const &json)
Returns true if the json contains an rpc error specification.
XrpT const XRP
Converts to XRP Issue or STAmount.
json::Value noop(Account const &account)
The null transaction.
std::array< Account, 1+sizeof...(Args)> noripple(Account const &account, Args const &... args)
Designate accounts as no-ripple in Env::fund.
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
std::unique_ptr< Config > onlineDelete(std::unique_ptr< Config > cfg, std::uint32_t deleteInterval=8)
adjust config to enable online_delete
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
std::uint32_t LedgerIndex
A ledger index.
std::unique_ptr< beast::Journal::Sink > setDebugLogSink(std::unique_ptr< beast::Journal::Sink > sink)
Set the sink for the debug journal.
std::string to_string(BaseUInt< Bits, Tag > const &a)
constexpr auto megabytes(T value) noexcept
OperatingMode
Specifies the mode under which the server believes it's operating.
@ DISCONNECTED
not ready to process requests
@ CONNECTED
convinced we are talking to the network
@ FULL
we have the ledger and can even validate
static constexpr auto kMaxWaitingLedgers
static constexpr auto kBackOffMilliseconds
static constexpr auto kAdvisoryDelete
static constexpr auto kCacheSize
static constexpr auto kDeleteBatch
static constexpr auto kRecoveryWaitSeconds
static constexpr auto kPath
static constexpr auto kCacheAge
static constexpr auto kOnlineDelete
static constexpr auto kNodeDatabase
T time_since_epoch(T... args)