Clio  develop
The XRP Ledger API server.
Loading...
Searching...
No Matches
data::BackendInterface Class Referenceabstract

The interface to the database used by Clio. More...

#include <BackendInterface.hpp>

Inheritance diagram for data::BackendInterface:
Collaboration diagram for data::BackendInterface:

Public Types

using ClioNodesDataFetchResult
 Return type for fetchClioNodesData() method.

Public Member Functions

 BackendInterface (LedgerCacheInterface &cache)
 Construct a new backend interface instance.
LedgerCacheInterface const & cache () const
LedgerCacheInterfacecache ()
void setCorruptionDetector (etl::CorruptionDetector detector)
 Sets the corruption detector.
virtual std::optional< ripple::LedgerHeader > fetchLedgerBySequence (std::uint32_t sequence, boost::asio::yield_context yield) const =0
 Fetches a specific ledger by sequence number.
virtual std::optional< ripple::LedgerHeader > fetchLedgerByHash (ripple::uint256 const &hash, boost::asio::yield_context yield) const =0
 Fetches a specific ledger by hash.
virtual std::optional< std::uint32_t > fetchLatestLedgerSequence (boost::asio::yield_context yield) const =0
 Fetches the latest ledger sequence.
std::optional< LedgerRangefetchLedgerRange () const
 Fetch the current ledger range.
virtual std::vector< ripple::uint256 > fetchAccountRoots (std::uint32_t number, std::uint32_t pageSize, std::uint32_t seq, boost::asio::yield_context yield) const =0
 Fetch the specified number of account root object indexes by page, the accounts need to exist for seq.
void updateRange (uint32_t newMax)
 Updates the range of sequences that are stored in the DB.
void setRange (uint32_t min, uint32_t max, bool force=false)
 Sets the range of sequences that are stored in the DB.
std::optional< ripple::Fees > fetchFees (std::uint32_t seq, boost::asio::yield_context yield) const
 Fetch the fees from a specific ledger sequence.
virtual std::optional< TransactionAndMetadatafetchTransaction (ripple::uint256 const &hash, boost::asio::yield_context yield) const =0
 Fetches a specific transaction.
virtual std::vector< TransactionAndMetadatafetchTransactions (std::vector< ripple::uint256 > const &hashes, boost::asio::yield_context yield) const =0
 Fetches multiple transactions.
virtual TransactionsAndCursor fetchAccountTransactions (ripple::AccountID const &account, std::uint32_t limit, bool forward, std::optional< TransactionsCursor > const &txnCursor, boost::asio::yield_context yield) const =0
 Fetches all transactions for a specific account.
virtual std::vector< TransactionAndMetadatafetchAllTransactionsInLedger (std::uint32_t ledgerSequence, boost::asio::yield_context yield) const =0
 Fetches all transactions from a specific ledger.
virtual std::vector< ripple::uint256 > fetchAllTransactionHashesInLedger (std::uint32_t ledgerSequence, boost::asio::yield_context yield) const =0
 Fetches all transaction hashes from a specific ledger.
virtual std::optional< NFTfetchNFT (ripple::uint256 const &tokenID, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const =0
 Fetches a specific NFT.
virtual TransactionsAndCursor fetchNFTTransactions (ripple::uint256 const &tokenID, std::uint32_t limit, bool forward, std::optional< TransactionsCursor > const &cursorIn, boost::asio::yield_context yield) const =0
 Fetches all transactions for a specific NFT.
virtual NFTsAndCursor fetchNFTsByIssuer (ripple::AccountID const &issuer, std::optional< std::uint32_t > const &taxon, std::uint32_t ledgerSequence, std::uint32_t limit, std::optional< ripple::uint256 > const &cursorIn, boost::asio::yield_context yield) const =0
 Fetches all NFTs issued by a given address.
virtual MPTHoldersAndCursor fetchMPTHolders (ripple::uint192 const &mptID, std::uint32_t const limit, std::optional< ripple::AccountID > const &cursorIn, std::uint32_t const ledgerSequence, boost::asio::yield_context yield) const =0
 Fetches all holders' balances for a MPTIssuanceID.
std::optional< Blob > fetchLedgerObject (ripple::uint256 const &key, std::uint32_t sequence, boost::asio::yield_context yield) const
 Fetches a specific ledger object.
std::optional< std::uint32_t > fetchLedgerObjectSeq (ripple::uint256 const &key, std::uint32_t sequence, boost::asio::yield_context yield) const
 Fetches a specific ledger object sequence.
std::vector< Blob > fetchLedgerObjects (std::vector< ripple::uint256 > const &keys, std::uint32_t sequence, boost::asio::yield_context yield) const
 Fetches all ledger objects by their keys.
virtual std::optional< Blob > doFetchLedgerObject (ripple::uint256 const &key, std::uint32_t sequence, boost::asio::yield_context yield) const =0
 The database-specific implementation for fetching a ledger object.
virtual std::optional< std::uint32_t > doFetchLedgerObjectSeq (ripple::uint256 const &key, std::uint32_t sequence, boost::asio::yield_context yield) const =0
 The database-specific implementation for fetching a ledger object sequence.
virtual std::vector< Blob > doFetchLedgerObjects (std::vector< ripple::uint256 > const &keys, std::uint32_t sequence, boost::asio::yield_context yield) const =0
 The database-specific implementation for fetching ledger objects.
virtual std::vector< LedgerObjectfetchLedgerDiff (std::uint32_t ledgerSequence, boost::asio::yield_context yield) const =0
 Returns the difference between ledgers.
LedgerPage fetchLedgerPage (std::optional< ripple::uint256 > const &cursor, std::uint32_t ledgerSequence, std::uint32_t limit, bool outOfOrder, boost::asio::yield_context yield)
 Fetches a page of ledger objects, ordered by key/index.
std::optional< LedgerObjectfetchSuccessorObject (ripple::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const
 Fetches the successor object.
std::optional< ripple::uint256 > fetchSuccessorKey (ripple::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const
 Fetches the successor key.
virtual std::optional< ripple::uint256 > doFetchSuccessorKey (ripple::uint256 key, std::uint32_t ledgerSequence, boost::asio::yield_context yield) const =0
 Database-specific implementation of fetching the successor key.
BookOffersPage fetchBookOffers (ripple::uint256 const &book, std::uint32_t ledgerSequence, std::uint32_t limit, boost::asio::yield_context yield) const
 Fetches book offers.
virtual std::optional< std::string > fetchMigratorStatus (std::string const &migratorName, boost::asio::yield_context yield) const =0
 Fetches the status of migrator by name.
virtual ClioNodesDataFetchResult fetchClioNodesData (boost::asio::yield_context yield) const =0
 Fetches the data of all nodes in the cluster.
std::optional< LedgerRangehardFetchLedgerRange () const
 Synchronously fetches the ledger range from DB.
virtual std::optional< LedgerRangehardFetchLedgerRange (boost::asio::yield_context yield) const =0
 Fetches the ledger range from DB.
std::optional< LedgerRangehardFetchLedgerRangeNoThrow () const
 Fetches the ledger range from DB retrying until no DatabaseTimeout is thrown.
virtual void writeLedger (ripple::LedgerHeader const &ledgerHeader, std::string &&blob)=0
 Writes to a specific ledger.
virtual void writeLedgerObject (std::string &&key, std::uint32_t seq, std::string &&blob)
 Writes a new ledger object.
virtual void writeTransaction (std::string &&hash, std::uint32_t seq, std::uint32_t date, std::string &&transaction, std::string &&metadata)=0
 Writes a new transaction.
virtual void writeNFTs (std::vector< NFTsData > const &data)=0
 Writes NFTs to the database.
virtual void writeAccountTransactions (std::vector< AccountTransactionsData > data)=0
 Write a new set of account transactions.
virtual void writeAccountTransaction (AccountTransactionsData record)=0
 Write a new account transaction.
virtual void writeNFTTransactions (std::vector< NFTTransactionsData > const &data)=0
 Write NFTs transactions.
virtual void writeMPTHolders (std::vector< MPTHolderData > const &data)=0
 Write accounts that started holding onto a MPT.
virtual void writeSuccessor (std::string &&key, std::uint32_t seq, std::string &&successor)=0
 Write a new successor.
virtual void writeNodeMessage (boost::uuids::uuid const &uuid, std::string message)=0
 Write a node message. Used by ClusterCommunicationService.
virtual void startWrites () const =0
 Starts a write transaction with the DB. No-op for cassandra.
bool finishWrites (std::uint32_t ledgerSequence)
 Tells database we finished writing all data for a specific ledger.
virtual void waitForWritesToFinish ()=0
 Wait for all pending writes to finish.
virtual void writeMigratorStatus (std::string const &migratorName, std::string const &status)=0
 Mark the migration status of a migrator as Migrated in the database.
virtual bool isTooBusy () const =0
virtual boost::json::object stats () const =0

Protected Attributes

util::Logger log_ {"Backend"}
std::shared_mutex rngMtx_
std::optional< LedgerRangerange_
std::reference_wrapper< LedgerCacheInterfacecache_
std::optional< etl::CorruptionDetectorcorruptionDetector_

Detailed Description

The interface to the database used by Clio.

Member Typedef Documentation

◆ ClioNodesDataFetchResult

Initial value:
std::expected<std::vector<std::pair<boost::uuids::uuid, std::string>>, std::string>

Return type for fetchClioNodesData() method.

Constructor & Destructor Documentation

◆ BackendInterface()

data::BackendInterface::BackendInterface ( LedgerCacheInterface & cache)
inline

Construct a new backend interface instance.

Parameters
cacheThe ledger cache to use

Member Function Documentation

◆ cache() [1/2]

LedgerCacheInterface & data::BackendInterface::cache ( )
inline
Returns
Mutable cache

◆ cache() [2/2]

LedgerCacheInterface const & data::BackendInterface::cache ( ) const
inline
Returns
Immutable cache

◆ doFetchLedgerObject()

◆ doFetchLedgerObjects()

◆ doFetchLedgerObjectSeq()

◆ doFetchSuccessorKey()

◆ fetchAccountRoots()

virtual std::vector< ripple::uint256 > data::BackendInterface::fetchAccountRoots ( std::uint32_t number,
std::uint32_t pageSize,
std::uint32_t seq,
boost::asio::yield_context yield ) const
pure virtual

Fetch the specified number of account root object indexes by page, the accounts need to exist for seq.

Parameters
numberThe number of accounts to fetch
pageSizeThe maximum number of accounts per page
seqThe accounts need to exist for this sequence
yieldThe coroutine context
Returns
A vector of ripple::uint256 representing the account roots

Implemented in data::cassandra::BasicCassandraBackend< SettingsProviderType, ExecutionStrategyType, FetchLedgerCacheType >, data::cassandra::BasicCassandraBackend< SettingsProvider, impl::DefaultExecutionStrategy<> >, data::cassandra::BasicKeyspaceBackend< SettingsProviderType, ExecutionStrategyType, FetchLedgerCacheType >, and data::cassandra::BasicKeyspaceBackend< SettingsProvider, impl::DefaultExecutionStrategy<> >.

◆ fetchAccountTransactions()

virtual TransactionsAndCursor data::BackendInterface::fetchAccountTransactions ( ripple::AccountID const & account,
std::uint32_t limit,
bool forward,
std::optional< TransactionsCursor > const & txnCursor,
boost::asio::yield_context yield ) const
pure virtual

◆ fetchAllTransactionHashesInLedger()

◆ fetchAllTransactionsInLedger()

◆ fetchBookOffers()

BookOffersPage data::BackendInterface::fetchBookOffers ( ripple::uint256 const & book,
std::uint32_t ledgerSequence,
std::uint32_t limit,
boost::asio::yield_context yield ) const

Fetches book offers.

Parameters
bookUnsigned 256-bit integer.
ledgerSequenceThe ledger sequence to fetch for
limitPagaing limit as to how many transactions returned per page.
yieldThe coroutine context
Returns
The book offers page

◆ fetchClioNodesData()

◆ fetchFees()

std::optional< ripple::Fees > data::BackendInterface::fetchFees ( std::uint32_t seq,
boost::asio::yield_context yield ) const

Fetch the fees from a specific ledger sequence.

Parameters
seqThe sequence to fetch for
yieldThe coroutine context
Returns
Fees if fees are found; nullopt otherwise

◆ fetchLatestLedgerSequence()

◆ fetchLedgerByHash()

◆ fetchLedgerBySequence()

◆ fetchLedgerDiff()

◆ fetchLedgerObject()

std::optional< Blob > data::BackendInterface::fetchLedgerObject ( ripple::uint256 const & key,
std::uint32_t sequence,
boost::asio::yield_context yield ) const

Fetches a specific ledger object.

Currently the real fetch happens in doFetchLedgerObject and fetchLedgerObject attempts to fetch from Cache first and only calls out to the real DB if a cache miss occurred.

Parameters
keyThe key of the object
sequenceThe ledger sequence to fetch for
yieldThe coroutine context
Returns
The object as a Blob on success; nullopt otherwise

◆ fetchLedgerObjects()

std::vector< Blob > data::BackendInterface::fetchLedgerObjects ( std::vector< ripple::uint256 > const & keys,
std::uint32_t sequence,
boost::asio::yield_context yield ) const

Fetches all ledger objects by their keys.

Currently the real fetch happens in doFetchLedgerObjects and fetchLedgerObjects attempts to fetch from Cache first and only calls out to the real DB for each of the keys that was not found in the cache.

Parameters
keysA vector with the keys of the objects to fetch
sequenceThe ledger sequence to fetch for
yieldThe coroutine context
Returns
A vector of ledger objects as Blobs

◆ fetchLedgerObjectSeq()

std::optional< std::uint32_t > data::BackendInterface::fetchLedgerObjectSeq ( ripple::uint256 const & key,
std::uint32_t sequence,
boost::asio::yield_context yield ) const

Fetches a specific ledger object sequence.

Currently the real fetch happens in doFetchLedgerObjectSeq

Parameters
keyThe key of the object
sequenceThe ledger sequence to fetch for
yieldThe coroutine context
Returns
The sequence in unit32_t on success; nullopt otherwise

◆ fetchLedgerPage()

LedgerPage data::BackendInterface::fetchLedgerPage ( std::optional< ripple::uint256 > const & cursor,
std::uint32_t ledgerSequence,
std::uint32_t limit,
bool outOfOrder,
boost::asio::yield_context yield )

Fetches a page of ledger objects, ordered by key/index.

Parameters
cursorThe cursor to resume fetching from
ledgerSequenceThe ledger sequence to fetch for
limitThe maximum number of transactions per result page
outOfOrderIf set to true max available sequence is used instead of ledgerSequence
yieldThe coroutine context
Returns
The ledger page

◆ fetchLedgerRange()

std::optional< LedgerRange > data::BackendInterface::fetchLedgerRange ( ) const

Fetch the current ledger range.

Returns
The current ledger range if populated; nullopt otherwise

◆ fetchMigratorStatus()

◆ fetchMPTHolders()

virtual MPTHoldersAndCursor data::BackendInterface::fetchMPTHolders ( ripple::uint192 const & mptID,
std::uint32_t const limit,
std::optional< ripple::AccountID > const & cursorIn,
std::uint32_t const ledgerSequence,
boost::asio::yield_context yield ) const
pure virtual

◆ fetchNFT()

◆ fetchNFTsByIssuer()

virtual NFTsAndCursor data::BackendInterface::fetchNFTsByIssuer ( ripple::AccountID const & issuer,
std::optional< std::uint32_t > const & taxon,
std::uint32_t ledgerSequence,
std::uint32_t limit,
std::optional< ripple::uint256 > const & cursorIn,
boost::asio::yield_context yield ) const
pure virtual

Fetches all NFTs issued by a given address.

Parameters
issuerAccountID of issuer you wish you query.
taxonOptional taxon of NFTs by which you wish to filter.
ledgerSequenceThe ledger sequence to fetch for
limitPaging limit.
cursorInOptional cursor to allow us to pick up from where we last left off.
yieldCurrently executing coroutine.
Returns
NFTs issued by this account, or this issuer/taxon combination if taxon is passed and an optional marker

Implemented in data::cassandra::BasicCassandraBackend< SettingsProviderType, ExecutionStrategyType, FetchLedgerCacheType >, data::cassandra::BasicCassandraBackend< SettingsProvider, impl::DefaultExecutionStrategy<> >, data::cassandra::BasicKeyspaceBackend< SettingsProviderType, ExecutionStrategyType, FetchLedgerCacheType >, and data::cassandra::BasicKeyspaceBackend< SettingsProvider, impl::DefaultExecutionStrategy<> >.

◆ fetchNFTTransactions()

virtual TransactionsAndCursor data::BackendInterface::fetchNFTTransactions ( ripple::uint256 const & tokenID,
std::uint32_t limit,
bool forward,
std::optional< TransactionsCursor > const & cursorIn,
boost::asio::yield_context yield ) const
pure virtual

◆ fetchSuccessorKey()

std::optional< ripple::uint256 > data::BackendInterface::fetchSuccessorKey ( ripple::uint256 key,
std::uint32_t ledgerSequence,
boost::asio::yield_context yield ) const

Fetches the successor key.

Thea real fetch happens in doFetchSuccessorKey. This function will attempt to lookup the successor in the cache first and only if it's not found in the cache will it fetch from the actual DB.

Parameters
keyThe key to fetch for
ledgerSequenceThe ledger sequence to fetch for
yieldThe coroutine context
Returns
The successor key on success; nullopt otherwise

◆ fetchSuccessorObject()

std::optional< LedgerObject > data::BackendInterface::fetchSuccessorObject ( ripple::uint256 key,
std::uint32_t ledgerSequence,
boost::asio::yield_context yield ) const

Fetches the successor object.

Parameters
keyThe key to fetch for
ledgerSequenceThe ledger sequence to fetch for
yieldThe coroutine context
Returns
The successor on success; nullopt otherwise

◆ fetchTransaction()

◆ fetchTransactions()

◆ finishWrites()

bool data::BackendInterface::finishWrites ( std::uint32_t ledgerSequence)

Tells database we finished writing all data for a specific ledger.

Uses doFinishWrites to synchronize with the pending writes.

Parameters
ledgerSequenceThe ledger sequence to finish writing for
Returns
true on success; false otherwise

◆ hardFetchLedgerRange() [1/2]

std::optional< LedgerRange > data::BackendInterface::hardFetchLedgerRange ( ) const

Synchronously fetches the ledger range from DB.

This function just wraps hardFetchLedgerRange(boost::asio::yield_context) using synchronous(FnType&&).

Returns
The ledger range if available; nullopt otherwise

◆ hardFetchLedgerRange() [2/2]

◆ hardFetchLedgerRangeNoThrow()

std::optional< LedgerRange > data::BackendInterface::hardFetchLedgerRangeNoThrow ( ) const

Fetches the ledger range from DB retrying until no DatabaseTimeout is thrown.

Returns
The ledger range if available; nullopt otherwise

◆ isTooBusy()

◆ setCorruptionDetector()

void data::BackendInterface::setCorruptionDetector ( etl::CorruptionDetector detector)
inline

Sets the corruption detector.

Parameters
detectorThe corruption detector to set

◆ setRange()

void data::BackendInterface::setRange ( uint32_t min,
uint32_t max,
bool force = false )

Sets the range of sequences that are stored in the DB.

Parameters
minThe new minimum sequence available
maxThe new maximum sequence available
forceIf set to true, the range will be set even if it's already set

◆ startWrites()

◆ stats()

◆ updateRange()

void data::BackendInterface::updateRange ( uint32_t newMax)

Updates the range of sequences that are stored in the DB.

Parameters
newMaxThe new maximum sequence available

◆ waitForWritesToFinish()

◆ writeAccountTransaction()

◆ writeAccountTransactions()

◆ writeLedger()

◆ writeLedgerObject()

void data::BackendInterface::writeLedgerObject ( std::string && key,
std::uint32_t seq,
std::string && blob )
virtual

Writes a new ledger object.

Parameters
keyThe key to write the ledger object under
seqThe ledger sequence to write for
blobThe data to write

◆ writeMigratorStatus()

◆ writeMPTHolders()

◆ writeNFTs()

◆ writeNFTTransactions()

◆ writeNodeMessage()

◆ writeSuccessor()

◆ writeTransaction()


The documentation for this class was generated from the following files: