server.h

Go to the documentation of this file.

// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2017-2019 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_RPC_SERVER_H
#define BITCOIN_RPC_SERVER_H
 
#include <common/system.h>
#include <rpc/command.h>
#include <rpc/request.h>
#include <rpc/util.h>
#include <rwcollection.h>
 
#include <univalue.h>
 
#include <cstdint>
#include <functional>
#include <map>
#include <string>
 
static const unsigned int DEFAULT_RPC_SERIALIZE_VERSION = 1;
 
class ArgsManager;
class CRPCCommand;
 
namespace RPCServerSignals {
void OnStarted(std::function<void()> slot);
void OnStopped(std::function<void()> slot);
} // namespace RPCServerSignals
 
class Config;
 
typedef std::map<std::string, std::unique_ptr<RPCCommand>> RPCCommandMap;
 
class RPCServer {
private:
    RWCollection<RPCCommandMap> commands;
 
public:
    RPCServer() {}
 
    RPCServer(const RPCServer &) = delete;
    RPCServer &operator=(const RPCServer &) = delete;
 
    UniValue ExecuteCommand(const Config &config,
                            const JSONRPCRequest &request) const;
 
    void RegisterCommand(std::unique_ptr<RPCCommand> command);
};
 
bool IsRPCRunning();
 
void RpcInterruptionPoint();
 
void SetRPCWarmupStatus(const std::string &newStatus);
 
void SetRPCWarmupFinished();
 
bool RPCIsInWarmup(std::string *outStatus);
 
class RPCTimerBase {
public:
    virtual ~RPCTimerBase() {}
};
 
class RPCTimerInterface {
public:
    virtual ~RPCTimerInterface() {}
 
    virtual const char *Name() = 0;
 
    virtual RPCTimerBase *NewTimer(std::function<void()> &func,
                                   int64_t millis) = 0;
};
 
void RPCSetTimerInterface(RPCTimerInterface *iface);
 
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface);
 
void RPCUnsetTimerInterface(RPCTimerInterface *iface);
 
void RPCRunLater(const std::string &name, std::function<void()> func,
                 int64_t nSeconds);
 
using RpcMethodFnType = RPCHelpMan (*)();
 
class CRPCCommand {
public:
    using Actor =
        std::function<bool(const Config &config, const JSONRPCRequest &request,
                           UniValue &result, bool last_handler)>;
 
    CRPCCommand(std::string _category, std::string _name, Actor _actor,
                std::vector<std::pair<std::string, bool>> _args,
                intptr_t _unique_id)
        : category(std::move(_category)), name(std::move(_name)),
          actor(std::move(_actor)), argNames(std::move(_args)),
          unique_id(_unique_id) {}
 
    CRPCCommand(std::string _category, RpcMethodFnType _fn)
        : CRPCCommand(
              _category, _fn().m_name,
              [_fn](const Config &config, const JSONRPCRequest &request,
                    UniValue &result, bool) {
                  result = _fn().HandleRequest(config, request);
                  return true;
              },
              _fn().GetArgNames(), intptr_t(_fn)) {}
 
    std::string category;
    std::string name;
    Actor actor;
    std::vector<std::pair<std::string, bool>> argNames;
    intptr_t unique_id;
};
 
class CRPCTable {
private:
    std::map<std::string, std::vector<const CRPCCommand *>> mapCommands;
 
public:
    CRPCTable();
    std::string help(const Config &config, const std::string &name,
                     const JSONRPCRequest &helpreq) const;
 
    UniValue execute(const Config &config, const JSONRPCRequest &request) const;
 
    std::vector<std::string> listCommands() const;
 
    UniValue dumpArgMap(const Config &config,
                        const JSONRPCRequest &request) const;
 
    void appendCommand(const std::string &name, const CRPCCommand *pcmd);
    bool removeCommand(const std::string &name, const CRPCCommand *pcmd);
};
 
bool IsDeprecatedRPCEnabled(const ArgsManager &args, const std::string &method);
 
extern CRPCTable tableRPC;
 
void StartRPC();
void InterruptRPC();
void StopRPC();
std::string JSONRPCExecBatch(const Config &config, RPCServer &rpcServer,
                             const JSONRPCRequest &req, const UniValue &vReq);
 
int RPCSerializationFlags();
 
#endif // BITCOIN_RPC_SERVER_H