Make database reads async

* yield on db read using asio
* PostgresBackend fetches multiple transactions or objects in parallel

src/backend/BackendInterface.h

@@ -37,12 +37,35 @@ retryOnTimeout(F func, size_t waitMs = 500)
     }
 }
 
+// Please note, this function only works w/ non-void return type. Writes are
+// synchronous anyways, so
+template <class F>
+void
+synchronous(F&& f)
+{
+    boost::asio::io_context ctx;
+    std::optional<boost::asio::io_context::work> work;
+
+    work.emplace(ctx);
+
+    boost::asio::spawn(ctx, [&f, &work](boost::asio::yield_context yield) {
+        f(yield);
+
+        work.reset();
+    });
+
+    ctx.run();
+}
+
 class BackendInterface
 {
 protected:
     std::optional<LedgerRange> range;
     SimpleCache cache_;
 
+    // mutex used for open() and close()
+    mutable std::mutex mutex_;
+
 public:
     BackendInterface(boost::json::object const& config)
     {
@@ -72,98 +95,150 @@ public:
     }
 
     virtual std::optional<ripple::LedgerInfo>
-    fetchLedgerBySequence(uint32_t sequence) const = 0;
+    fetchLedgerBySequence(
+        std::uint32_t const sequence,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual std::optional<ripple::LedgerInfo>
-    fetchLedgerByHash(ripple::uint256 const& hash) const = 0;
+    fetchLedgerByHash(
+        ripple::uint256 const& hash,
+        boost::asio::yield_context& yield) const = 0;
 
-    virtual std::optional<uint32_t>
-    fetchLatestLedgerSequence() const = 0;
+    virtual std::optional<std::uint32_t>
+    fetchLatestLedgerSequence(boost::asio::yield_context& yield) const = 0;
 
     std::optional<LedgerRange>
     fetchLedgerRange() const
     {
+        std::lock_guard lk(mutex_);
         return range;
     }
 
     std::optional<ripple::Fees>
-    fetchFees(std::uint32_t seq) const;
+    fetchFees(std::uint32_t const seq, boost::asio::yield_context& yield) const;
 
     // *** transaction methods
     virtual std::optional<TransactionAndMetadata>
-    fetchTransaction(ripple::uint256 const& hash) const = 0;
+    fetchTransaction(
+        ripple::uint256 const& hash,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual std::vector<TransactionAndMetadata>
-    fetchTransactions(std::vector<ripple::uint256> const& hashes) const = 0;
+    fetchTransactions(
+        std::vector<ripple::uint256> const& hashes,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual AccountTransactions
     fetchAccountTransactions(
         ripple::AccountID const& account,
-        std::uint32_t limit,
-        bool forward = false,
-        std::optional<AccountTransactionsCursor> const& cursor = {}) const = 0;
+        std::uint32_t const limit,
+        bool forward,
+        std::optional<AccountTransactionsCursor> const& cursor,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual std::vector<TransactionAndMetadata>
-    fetchAllTransactionsInLedger(uint32_t ledgerSequence) const = 0;
+    fetchAllTransactionsInLedger(
+        std::uint32_t const ledgerSequence,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual std::vector<ripple::uint256>
-    fetchAllTransactionHashesInLedger(uint32_t ledgerSequence) const = 0;
+    fetchAllTransactionHashesInLedger(
+        std::uint32_t const ledgerSequence,
+        boost::asio::yield_context& yield) const = 0;
 
     // *** state data methods
     std::optional<Blob>
-    fetchLedgerObject(ripple::uint256 const& key, uint32_t sequence) const;
+    fetchLedgerObject(
+        ripple::uint256 const& key,
+        std::uint32_t const sequence,
+        boost::asio::yield_context& yield) const;
 
     std::vector<Blob>
     fetchLedgerObjects(
         std::vector<ripple::uint256> const& keys,
-        uint32_t sequence) const;
+        std::uint32_t const sequence,
+        boost::asio::yield_context& yield) const;
+
     virtual std::optional<Blob>
-    doFetchLedgerObject(ripple::uint256 const& key, uint32_t sequence)
-        const = 0;
+    doFetchLedgerObject(
+        ripple::uint256 const& key,
+        std::uint32_t const sequence,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual std::vector<Blob>
     doFetchLedgerObjects(
         std::vector<ripple::uint256> const& keys,
-        uint32_t sequence) const = 0;
+        std::uint32_t const sequence,
+        boost::asio::yield_context& yield) const = 0;
 
     virtual std::vector<LedgerObject>
-    fetchLedgerDiff(uint32_t ledgerSequence) const = 0;
+    fetchLedgerDiff(
+        std::uint32_t const ledgerSequence,
+        boost::asio::yield_context& yield) const = 0;
 
     // Fetches a page of ledger objects, ordered by key/index.
     // Used by ledger_data
     LedgerPage
     fetchLedgerPage(
         std::optional<ripple::uint256> const& cursor,
-        std::uint32_t ledgerSequence,
-        std::uint32_t limit,
-        std::uint32_t limitHint = 0) const;
+        std::uint32_t const ledgerSequence,
+        std::uint32_t const limit,
+        std::uint32_t const limitHint,
+        boost::asio::yield_context& yield) const;
 
     // Fetches the successor to key/index
     std::optional<LedgerObject>
-    fetchSuccessorObject(ripple::uint256 key, uint32_t ledgerSequence) const;
+    fetchSuccessorObject(
+        ripple::uint256 key,
+        std::uint32_t const ledgerSequence,
+        boost::asio::yield_context& yield) const;
 
     std::optional<ripple::uint256>
-    fetchSuccessorKey(ripple::uint256 key, uint32_t ledgerSequence) const;
+    fetchSuccessorKey(
+        ripple::uint256 key,
+        std::uint32_t const ledgerSequence,
+        boost::asio::yield_context& yield) const;
     // Fetches the successor to key/index
+
     virtual std::optional<ripple::uint256>
-    doFetchSuccessorKey(ripple::uint256 key, uint32_t ledgerSequence) const = 0;
+    doFetchSuccessorKey(
+        ripple::uint256 key,
+        std::uint32_t const ledgerSequence,
+        boost::asio::yield_context& yield) const = 0;
 
     BookOffersPage
     fetchBookOffers(
         ripple::uint256 const& book,
-        uint32_t ledgerSequence,
-        std::uint32_t limit,
-        std::optional<ripple::uint256> const& cursor = {}) const;
+        std::uint32_t const ledgerSequence,
+        std::uint32_t const limit,
+        std::optional<ripple::uint256> const& cursor,
+        boost::asio::yield_context& yield) const;
+
+    std::optional<LedgerRange>
+    hardFetchLedgerRange() const
+    {
+        std::optional<LedgerRange> range = {};
+        synchronous([&](boost::asio::yield_context yield) {
+            range = hardFetchLedgerRange(yield);
+        });
+
+        return range;
+    }
 
     virtual std::optional<LedgerRange>
-    hardFetchLedgerRange() const = 0;
+    hardFetchLedgerRange(boost::asio::yield_context& yield) const = 0;
+
     // Doesn't throw DatabaseTimeout. Should be used with care.
     std::optional<LedgerRange>
     hardFetchLedgerRangeNoThrow() const;
+    // Doesn't throw DatabaseTimeout. Should be used with care.
+    std::optional<LedgerRange>
+    hardFetchLedgerRangeNoThrow(boost::asio::yield_context& yield) const;
 
     void
-    updateRange(uint32_t newMax)
+    updateRange(std::uint32_t const newMax)
     {
+        std::lock_guard lk(mutex_);
         if (!range)
             range = {newMax, newMax};
         else
@@ -175,14 +250,17 @@ public:
         ripple::LedgerInfo const& ledgerInfo,
         std::string&& ledgerHeader) = 0;
 
-    void
-    writeLedgerObject(std::string&& key, uint32_t seq, std::string&& blob);
+    virtual void
+    writeLedgerObject(
+        std::string&& key,
+        std::uint32_t const seq,
+        std::string&& blob);
 
     virtual void
     writeTransaction(
         std::string&& hash,
-        uint32_t seq,
-        uint32_t date,
+        std::uint32_t const seq,
+        std::uint32_t const date,
         std::string&& transaction,
         std::string&& metadata) = 0;
 
@@ -192,20 +270,23 @@ public:
     virtual void
     writeSuccessor(
         std::string&& key,
-        uint32_t seq,
+        std::uint32_t const seq,
         std::string&& successor) = 0;
+
     // Tell the database we are about to begin writing data for a particular
     // ledger.
     virtual void
-    startWrites() = 0;
+    startWrites() const = 0;
 
     // Tell the database we have finished writing all data for a particular
     // ledger
     bool
-    finishWrites(uint32_t ledgerSequence);
+    finishWrites(std::uint32_t const ledgerSequence);
 
     virtual bool
-    doOnlineDelete(uint32_t numLedgersToKeep) const = 0;
+    doOnlineDelete(
+        std::uint32_t numLedgersToKeep,
+        boost::asio::yield_context& yield) const = 0;
 
     // Open the database. Set up all of the necessary objects and
     // datastructures. After this call completes, the database is ready for
@@ -215,18 +296,18 @@ public:
 
     // Close the database, releasing any resources
     virtual void
-    close() = 0;
+    close(){};
 
     // *** private helper methods
 private:
     virtual void
     doWriteLedgerObject(
         std::string&& key,
-        uint32_t seq,
+        std::uint32_t const seq,
         std::string&& blob) = 0;
 
     virtual bool
-    doFinishWrites() = 0;
+    doFinishWrites() const = 0;
 };
 
 }  // namespace Backend