mirror of
https://github.com/Xahau/xahaud.git
synced 2025-11-19 18:15:50 +00:00
100 lines
3.0 KiB
C++
100 lines
3.0 KiB
C++
#ifndef RIPPLE_APP_MAIN_STATEACCOUNTING_H_INCLUDED
|
|
#define RIPPLE_APP_MAIN_STATEACCOUNTING_H_INCLUDED
|
|
|
|
#include <ripple/basics/chrono.h>
|
|
#include <ripple/beast/utility/Journal.h>
|
|
#include <ripple/json/json_value.h>
|
|
#include <ripple/protocol/jss.h>
|
|
#include <array>
|
|
#include <mutex>
|
|
|
|
namespace ripple {
|
|
|
|
// This is the primary interface into the "client" portion of the program.
|
|
// Code that wants to do normal operations on the network such as
|
|
// creating and monitoring accounts, creating transactions, and so on
|
|
// should use this interface. The RPC code will primarily be a light wrapper
|
|
// over this code.
|
|
//
|
|
// Eventually, it will check the node's operating mode (synched, unsynched,
|
|
// etectera) and defer to the correct means of processing. The current
|
|
// code assumes this node is synched (and will continue to do so until
|
|
// there's a functional network.
|
|
//
|
|
|
|
/** Specifies the mode under which the server believes it's operating.
|
|
|
|
This has implications about how the server processes transactions and
|
|
how it responds to requests (e.g. account balance request).
|
|
|
|
@note Other code relies on the numerical values of these constants; do
|
|
not change them without verifying each use and ensuring that it is
|
|
not a breaking change.
|
|
*/
|
|
enum class OperatingMode {
|
|
DISCONNECTED = 0, //!< not ready to process requests
|
|
CONNECTED = 1, //!< convinced we are talking to the network
|
|
SYNCING = 2, //!< fallen slightly behind
|
|
TRACKING = 3, //!< convinced we agree with the network
|
|
FULL = 4 //!< we have the ledger and can even validate
|
|
};
|
|
|
|
class StateAccounting
|
|
{
|
|
public:
|
|
constexpr static std::array<Json::StaticString const, 5> const states_ = {
|
|
{Json::StaticString("disconnected"),
|
|
Json::StaticString("connected"),
|
|
Json::StaticString("syncing"),
|
|
Json::StaticString("tracking"),
|
|
Json::StaticString("full")}};
|
|
|
|
struct Counters
|
|
{
|
|
explicit Counters() = default;
|
|
|
|
std::uint64_t transitions = 0;
|
|
std::chrono::microseconds dur = std::chrono::microseconds(0);
|
|
};
|
|
|
|
private:
|
|
OperatingMode mode_ = OperatingMode::DISCONNECTED;
|
|
std::array<Counters, 5> counters_;
|
|
mutable std::mutex mutex_;
|
|
std::chrono::steady_clock::time_point start_ =
|
|
std::chrono::steady_clock::now();
|
|
std::chrono::steady_clock::time_point const processStart_ = start_;
|
|
std::uint64_t initialSyncUs_{0};
|
|
|
|
public:
|
|
explicit StateAccounting()
|
|
{
|
|
counters_[static_cast<std::size_t>(OperatingMode::DISCONNECTED)]
|
|
.transitions = 1;
|
|
}
|
|
|
|
//! Record state transition. Update duration spent in previous state.
|
|
void
|
|
mode(OperatingMode om);
|
|
|
|
//! Output state counters in JSON format.
|
|
void
|
|
json(Json::Value& obj);
|
|
|
|
using CounterData = std::tuple<
|
|
decltype(counters_),
|
|
decltype(mode_),
|
|
decltype(start_),
|
|
decltype(initialSyncUs_)>;
|
|
|
|
CounterData
|
|
getCounterData()
|
|
{
|
|
return {counters_, mode_, start_, initialSyncUs_};
|
|
}
|
|
};
|
|
|
|
} // namespace ripple
|
|
|
|
#endif
|