ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-12-05 16:58:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename CassandraFlatMapBackend to CassandraBackend and rename file

Browse Source
This commit is contained in:
CJ Cobb
2021-03-02 10:23:58 -05:00
parent 805bc14994
commit 8691cff8df
4 changed files with 52 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -56,7 +56,7 @@ include(Postgres)
target_sources(reporting PRIVATE target_sources(reporting PRIVATE
reporting/ETLSource.cpp reporting/ETLSource.cpp
reporting/ReportingBackend.cpp reporting/CassandraBackend.cpp
reporting/PostgresBackend.cpp reporting/PostgresBackend.cpp
reporting/Pg.cpp reporting/Pg.cpp
reporting/DBHelpers.cpp reporting/DBHelpers.cpp

4
reporting/BackendFactory.h
View File

@@ -1,7 +1,7 @@
#ifndef RIPPLE_APP_REPORTING_BACKENDFACTORY_H_INCLUDED #ifndef RIPPLE_APP_REPORTING_BACKENDFACTORY_H_INCLUDED
#define RIPPLE_APP_REPORTING_BACKENDFACTORY_H_INCLUDED #define RIPPLE_APP_REPORTING_BACKENDFACTORY_H_INCLUDED
#include <reporting/BackendInterface.h> #include <reporting/BackendInterface.h>
#include <reporting/ReportingBackend.h> #include <reporting/CassandraBackend.h>
namespace Backend { namespace Backend {
std::unique_ptr<BackendInterface> std::unique_ptr<BackendInterface>
makeBackend(boost::json::object const& config) makeBackend(boost::json::object const& config)
@@ -10,7 +10,7 @@ makeBackend(boost::json::object const& config)
if (dbConfig.contains("cassandra")) if (dbConfig.contains("cassandra"))
{ {
auto backend = std::make_unique<CassandraFlatMapBackend>( auto backend = std::make_unique<CassandraBackend>(
dbConfig.at("cassandra").as_object()); dbConfig.at("cassandra").as_object());
return std::move(backend); return std::move(backend);
} }

64
reporting/ReportingBackend.cpp → reporting/CassandraBackend.cpp
View File

@@ -1,4 +1,4 @@
#include <reporting/ReportingBackend.h> #include <reporting/CassandraBackend.h>
namespace Backend { namespace Backend {
// Process the result of an asynchronous write. Retry on error // Process the result of an asynchronous write. Retry on error
// @param fut cassandra future associated with the write // @param fut cassandra future associated with the write
@@ -6,9 +6,9 @@ namespace Backend {
void void
flatMapWriteCallback(CassFuture* fut, void* cbData) flatMapWriteCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteCallbackData& requestParams = CassandraBackend::WriteCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteCallbackData*>(cbData); *static_cast<CassandraBackend::WriteCallbackData*>(cbData);
CassandraFlatMapBackend const& backend = *requestParams.backend; CassandraBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -42,9 +42,9 @@ flatMapWriteCallback(CassFuture* fut, void* cbData)
void void
flatMapWriteBookCallback(CassFuture* fut, void* cbData) flatMapWriteBookCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteCallbackData& requestParams = CassandraBackend::WriteCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteCallbackData*>(cbData); *static_cast<CassandraBackend::WriteCallbackData*>(cbData);
CassandraFlatMapBackend const& backend = *requestParams.backend; CassandraBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -79,9 +79,9 @@ flatMapWriteBookCallback(CassFuture* fut, void* cbData)
void void
flatMapWriteKeyCallback(CassFuture* fut, void* cbData) flatMapWriteKeyCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteCallbackData& requestParams = CassandraBackend::WriteCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteCallbackData*>(cbData); *static_cast<CassandraBackend::WriteCallbackData*>(cbData);
CassandraFlatMapBackend const& backend = *requestParams.backend; CassandraBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -118,9 +118,9 @@ flatMapWriteKeyCallback(CassFuture* fut, void* cbData)
void void
flatMapGetCreatedCallback(CassFuture* fut, void* cbData) flatMapGetCreatedCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteCallbackData& requestParams = CassandraBackend::WriteCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteCallbackData*>(cbData); *static_cast<CassandraBackend::WriteCallbackData*>(cbData);
CassandraFlatMapBackend const& backend = *requestParams.backend; CassandraBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -178,10 +178,9 @@ flatMapGetCreatedCallback(CassFuture* fut, void* cbData)
void void
flatMapWriteTransactionCallback(CassFuture* fut, void* cbData) flatMapWriteTransactionCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteTransactionCallbackData& requestParams = CassandraBackend::WriteTransactionCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteTransactionCallbackData*>( *static_cast<CassandraBackend::WriteTransactionCallbackData*>(cbData);
cbData); CassandraBackend const& backend = *requestParams.backend;
CassandraFlatMapBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -213,10 +212,9 @@ flatMapWriteTransactionCallback(CassFuture* fut, void* cbData)
void void
flatMapWriteAccountTxCallback(CassFuture* fut, void* cbData) flatMapWriteAccountTxCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteAccountTxCallbackData& requestParams = CassandraBackend::WriteAccountTxCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteAccountTxCallbackData*>( *static_cast<CassandraBackend::WriteAccountTxCallbackData*>(cbData);
cbData); CassandraBackend const& backend = *requestParams.backend;
CassandraFlatMapBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -250,10 +248,9 @@ flatMapWriteAccountTxCallback(CassFuture* fut, void* cbData)
void void
flatMapWriteLedgerHeaderCallback(CassFuture* fut, void* cbData) flatMapWriteLedgerHeaderCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteLedgerHeaderCallbackData& requestParams = CassandraBackend::WriteLedgerHeaderCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteLedgerHeaderCallbackData*>( *static_cast<CassandraBackend::WriteLedgerHeaderCallbackData*>(cbData);
cbData); CassandraBackend const& backend = *requestParams.backend;
CassandraFlatMapBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -285,10 +282,9 @@ flatMapWriteLedgerHeaderCallback(CassFuture* fut, void* cbData)
void void
flatMapWriteLedgerHashCallback(CassFuture* fut, void* cbData) flatMapWriteLedgerHashCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::WriteLedgerHashCallbackData& requestParams = CassandraBackend::WriteLedgerHashCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::WriteLedgerHashCallbackData*>( *static_cast<CassandraBackend::WriteLedgerHashCallbackData*>(cbData);
cbData); CassandraBackend const& backend = *requestParams.backend;
CassandraFlatMapBackend const& backend = *requestParams.backend;
auto rc = cass_future_error_code(fut); auto rc = cass_future_error_code(fut);
if (rc != CASS_OK) if (rc != CASS_OK)
{ {
@@ -324,8 +320,8 @@ flatMapWriteLedgerHashCallback(CassFuture* fut, void* cbData)
void void
flatMapReadCallback(CassFuture* fut, void* cbData) flatMapReadCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::ReadCallbackData& requestParams = CassandraBackend::ReadCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::ReadCallbackData*>(cbData); *static_cast<CassandraBackend::ReadCallbackData*>(cbData);
CassError rc = cass_future_error_code(fut); CassError rc = cass_future_error_code(fut);
@@ -398,8 +394,8 @@ flatMapReadCallback(CassFuture* fut, void* cbData)
void void
flatMapReadObjectCallback(CassFuture* fut, void* cbData) flatMapReadObjectCallback(CassFuture* fut, void* cbData)
{ {
CassandraFlatMapBackend::ReadObjectCallbackData& requestParams = CassandraBackend::ReadObjectCallbackData& requestParams =
*static_cast<CassandraFlatMapBackend::ReadObjectCallbackData*>(cbData); *static_cast<CassandraBackend::ReadObjectCallbackData*>(cbData);
CassError rc = cass_future_error_code(fut); CassError rc = cass_future_error_code(fut);
@@ -457,7 +453,7 @@ flatMapReadObjectCallback(CassFuture* fut, void* cbData)
} }
void void
CassandraFlatMapBackend::open() CassandraBackend::open()
{ {
std::cout << config_ << std::endl; std::cout << config_ << std::endl;
auto getString = [this](std::string const& field) -> std::string { auto getString = [this](std::string const& field) -> std::string {

38
reporting/ReportingBackend.h → reporting/CassandraBackend.h
View File

@@ -17,8 +17,8 @@
*/ */
//============================================================================== //==============================================================================
#ifndef RIPPLE_APP_REPORTING_REPORTINGBACKEND_H_INCLUDED #ifndef RIPPLE_APP_REPORTING_CASSANDRABACKEND_H_INCLUDED
#define RIPPLE_APP_REPORTING_REPORTINGBACKEND_H_INCLUDED #define RIPPLE_APP_REPORTING_CASSANDRABACKEND_H_INCLUDED
#include <ripple/basics/base_uint.h> #include <ripple/basics/base_uint.h>
#include <boost/asio.hpp> #include <boost/asio.hpp>
@@ -57,7 +57,7 @@ flatMapWriteLedgerHeaderCallback(CassFuture* fut, void* cbData);
void void
flatMapWriteLedgerHashCallback(CassFuture* fut, void* cbData); flatMapWriteLedgerHashCallback(CassFuture* fut, void* cbData);
class CassandraFlatMapBackend : public BackendInterface class CassandraBackend : public BackendInterface
{ {
private: private:
// convenience function for one-off queries. For normal reads and writes, // convenience function for one-off queries. For normal reads and writes,
@@ -142,11 +142,11 @@ private:
mutable bool isFirstLedger_ = false; mutable bool isFirstLedger_ = false;
public: public:
CassandraFlatMapBackend(boost::json::object const& config) : config_(config) CassandraBackend(boost::json::object const& config) : config_(config)
{ {
} }
~CassandraFlatMapBackend() override ~CassandraBackend() override
{ {
if (open_) if (open_)
close(); close();
@@ -395,13 +395,13 @@ public:
struct WriteLedgerHeaderCallbackData struct WriteLedgerHeaderCallbackData
{ {
CassandraFlatMapBackend const* backend; CassandraBackend const* backend;
uint32_t sequence; uint32_t sequence;
std::string header; std::string header;
uint32_t currentRetries = 0; uint32_t currentRetries = 0;
WriteLedgerHeaderCallbackData( WriteLedgerHeaderCallbackData(
CassandraFlatMapBackend const* f, CassandraBackend const* f,
uint32_t sequence, uint32_t sequence,
std::string&& header) std::string&& header)
: backend(f), sequence(sequence), header(std::move(header)) : backend(f), sequence(sequence), header(std::move(header))
@@ -410,13 +410,13 @@ public:
}; };
struct WriteLedgerHashCallbackData struct WriteLedgerHashCallbackData
{ {
CassandraFlatMapBackend const* backend; CassandraBackend const* backend;
ripple::uint256 hash; ripple::uint256 hash;
uint32_t sequence; uint32_t sequence;
uint32_t currentRetries = 0; uint32_t currentRetries = 0;
WriteLedgerHashCallbackData( WriteLedgerHashCallbackData(
CassandraFlatMapBackend const* f, CassandraBackend const* f,
ripple::uint256 hash, ripple::uint256 hash,
uint32_t sequence) uint32_t sequence)
: backend(f), hash(hash), sequence(sequence) : backend(f), hash(hash), sequence(sequence)
@@ -1185,7 +1185,7 @@ public:
struct ReadCallbackData struct ReadCallbackData
{ {
CassandraFlatMapBackend const& backend; CassandraBackend const& backend;
ripple::uint256 const& hash; ripple::uint256 const& hash;
TransactionAndMetadata& result; TransactionAndMetadata& result;
std::condition_variable& cv; std::condition_variable& cv;
@@ -1194,7 +1194,7 @@ public:
size_t batchSize; size_t batchSize;
ReadCallbackData( ReadCallbackData(
CassandraFlatMapBackend const& backend, CassandraBackend const& backend,
ripple::uint256 const& hash, ripple::uint256 const& hash,
TransactionAndMetadata& result, TransactionAndMetadata& result,
std::condition_variable& cv, std::condition_variable& cv,
@@ -1274,7 +1274,7 @@ public:
struct ReadObjectCallbackData struct ReadObjectCallbackData
{ {
CassandraFlatMapBackend const& backend; CassandraBackend const& backend;
ripple::uint256 const& key; ripple::uint256 const& key;
uint32_t sequence; uint32_t sequence;
Blob& result; Blob& result;
@@ -1284,7 +1284,7 @@ public:
size_t batchSize; size_t batchSize;
ReadObjectCallbackData( ReadObjectCallbackData(
CassandraFlatMapBackend const& backend, CassandraBackend const& backend,
ripple::uint256 const& key, ripple::uint256 const& key,
uint32_t sequence, uint32_t sequence,
Blob& result, Blob& result,
@@ -1380,7 +1380,7 @@ public:
struct WriteCallbackData struct WriteCallbackData
{ {
CassandraFlatMapBackend const* backend; CassandraBackend const* backend;
std::string key; std::string key;
uint32_t sequence; uint32_t sequence;
uint32_t createdSequence = 0; uint32_t createdSequence = 0;
@@ -1393,7 +1393,7 @@ public:
std::atomic<int> refs = 1; std::atomic<int> refs = 1;
WriteCallbackData( WriteCallbackData(
CassandraFlatMapBackend const* f, CassandraBackend const* f,
std::string&& key, std::string&& key,
uint32_t sequence, uint32_t sequence,
std::string&& blob, std::string&& blob,
@@ -1416,14 +1416,14 @@ public:
}; };
struct WriteAccountTxCallbackData struct WriteAccountTxCallbackData
{ {
CassandraFlatMapBackend const* backend; CassandraBackend const* backend;
AccountTransactionsData data; AccountTransactionsData data;
uint32_t currentRetries = 0; uint32_t currentRetries = 0;
std::atomic<int> refs; std::atomic<int> refs;
WriteAccountTxCallbackData( WriteAccountTxCallbackData(
CassandraFlatMapBackend const* f, CassandraBackend const* f,
AccountTransactionsData&& data) AccountTransactionsData&& data)
: backend(f), data(std::move(data)), refs(data.accounts.size()) : backend(f), data(std::move(data)), refs(data.accounts.size())
{ {
@@ -1858,7 +1858,7 @@ public:
struct WriteTransactionCallbackData struct WriteTransactionCallbackData
{ {
CassandraFlatMapBackend const* backend; CassandraBackend const* backend;
// The shared pointer to the node object must exist until it's // The shared pointer to the node object must exist until it's
// confirmed persisted. Otherwise, it can become deleted // confirmed persisted. Otherwise, it can become deleted
// prematurely if other copies are removed from caches. // prematurely if other copies are removed from caches.
@@ -1870,7 +1870,7 @@ public:
uint32_t currentRetries = 0; uint32_t currentRetries = 0;
WriteTransactionCallbackData( WriteTransactionCallbackData(
CassandraFlatMapBackend const* f, CassandraBackend const* f,
std::string&& hash, std::string&& hash,
uint32_t sequence, uint32_t sequence,
std::string&& transaction, std::string&& transaction,