22 #include <boost/signals2/signal.hpp>
28 #include <unordered_map>
59 std::list<RPCCommandExecutionInfo>::iterator
it;
92 std::set<intptr_t> setDone;
93 std::vector<std::pair<std::string, const CRPCCommand*> > vCommands;
97 vCommands.emplace_back(entry.second.front()->category + entry.first, entry.second.front());
98 sort(vCommands.begin(), vCommands.end());
104 for (
const std::pair<std::string, const CRPCCommand*>&
command : vCommands)
107 std::string strMethod = pcmd->
name;
108 if ((strCommand !=
"" || pcmd->
category ==
"hidden") && strMethod != strCommand)
114 if (setDone.insert(pcmd->
unique_id).second)
115 pcmd->
actor(jreq, unused_result,
true);
117 catch (
const std::exception& e)
120 std::string strHelp = std::string(e.what());
121 if (strCommand ==
"")
123 if (strHelp.find(
'\n') != std::string::npos)
124 strHelp = strHelp.substr(0, strHelp.find(
'\n'));
128 if (!category.empty())
131 strRet +=
"== " +
Capitalize(category) +
" ==\n";
134 strRet += strHelp +
"\n";
138 strRet =
strprintf(
"help: unknown command: %s\n", strCommand);
139 strRet = strRet.substr(0,strRet.size()-1);
146 "\nList all commands, or get help for a specified command.\n",
157 std::string strCommand;
158 if (jsonRequest.params.size() > 0) {
159 strCommand = jsonRequest.params[0].
get_str();
161 if (strCommand ==
"dump_all_command_conversions") {
173 static const std::string RESULT{
PACKAGE_NAME " stopping"};
189 if (jsonRequest.params[0].isNum()) {
200 "\nReturns the total uptime of the server.\n",
219 "\nReturns details of the RPC server.\n",
245 entry.
pushKV(
"duration", int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - info.
start)});
246 active_commands.
push_back(std::move(entry));
250 result.
pushKV(
"active_commands", std::move(active_commands));
254 result.
pushKV(
"logpath", std::move(log_path));
287 auto new_end = std::remove(it->second.begin(), it->second.end(), pcmd);
288 if (it->second.end() != new_end) {
289 it->second.erase(new_end, it->second.end());
305 static std::once_flag g_rpc_interrupt_flag;
307 std::call_once(g_rpc_interrupt_flag, []() {
316 static std::once_flag g_rpc_stop_flag;
319 std::call_once(g_rpc_stop_flag, []() {
340 rpcWarmupStatus = newStatus;
347 fRPCInWarmup =
false;
354 *outStatus = rpcWarmupStatus;
360 const std::vector<std::string> enabled_methods =
gArgs.
GetArgs(
"-deprecatedrpc");
362 return find(enabled_methods.begin(), enabled_methods.end(), method) != enabled_methods.end();
373 }
catch (
const std::exception& e) {
395 std::unordered_map<std::string, const UniValue*> argsIn;
396 for (
size_t i=0; i<keys.size(); ++i) {
397 auto [
_, inserted] = argsIn.emplace(keys[i], &
values[i]);
411 int initial_hole_size = 0;
412 const std::string* initial_param =
nullptr;
414 for (
const auto& [argNamePattern, named_only]: argNames) {
415 std::vector<std::string> vargNames =
SplitString(argNamePattern,
'|');
416 auto fr = argsIn.end();
417 for (
const std::string & argName : vargNames) {
418 fr = argsIn.find(argName);
419 if (fr != argsIn.end()) {
428 if (fr != argsIn.end()) {
429 if (options.exists(fr->first)) {
432 options.pushKVEnd(fr->first, *fr->second);
438 if (!options.empty() || fr != argsIn.end()) {
439 for (
int i = 0; i < hole; ++i) {
446 if (!initial_param) initial_param = &argNamePattern;
449 if (
out.params.empty()) initial_hole_size = hole;
455 if (fr != argsIn.end()) {
456 if (!options.empty()) {
459 out.params.push_back(*fr->second);
462 if (!options.empty()) {
463 out.params.push_back(std::move(options));
471 auto positional_args{argsIn.extract(
"args")};
472 if (positional_args && positional_args.mapped()->isArray()) {
473 if (initial_hole_size < (
int)positional_args.mapped()->size() && initial_param) {
478 out.params = *positional_args.mapped();
479 for (
size_t i{
out.params.size()}; i < named_args.size(); ++i) {
480 out.params.push_back(named_args[i]);
484 if (!argsIn.empty()) {
493 for (
const auto&
command : commands) {
529 return command.actor(request, result, last_handler);
533 }
catch (
const std::exception& e) {
540 std::vector<std::string> commandList;
542 for (
const auto& i :
mapCommands) commandList.emplace_back(i.first);
580 void RPCRunLater(
const std::string&
name, std::function<
void()> func, int64_t nSeconds)
585 deadlineTimers.erase(
name);
#define CHECK_NONFATAL(condition)
Identity function.
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
std::map< std::string, std::vector< const CRPCCommand * > > mapCommands
bool removeCommand(const std::string &name, const CRPCCommand *pcmd)
std::vector< std::string > listCommands() const
Returns a list of registered commands.
UniValue execute(const JSONRPCRequest &request) const
Execute a method.
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
std::string help(const std::string &name, const JSONRPCRequest &helpreq) const
UniValue dumpArgMap(const JSONRPCRequest &request) const
Return all named arguments that need to be converted by the client from string to another JSON type.
Different type to mark Mutex at global scope.
JSONRPCVersion m_json_version
enum JSONRPCRequest::Mode mode
std::optional< UniValue > id
virtual RPCTimerBase * NewTimer(std::function< void()> &func, int64_t millis)=0
Factory function for timers.
virtual const char * Name()=0
Implementation name.
void push_back(UniValue val)
const std::string & get_str() const
const std::vector< UniValue > & getValues() const
const std::vector< std::string > & getKeys() const
void pushKV(std::string key, UniValue val)
std::string utf8string() const
Return a UTF-8 representation of the path as a std::string, for compatibility with code using std::st...
BCLog::Logger & LogInstance()
#define LogPrint(category,...)
void OnStarted(std::function< void()> slot)
void OnStopped(std::function< void()> slot)
std::vector< std::string > SplitString(std::string_view str, char sep)
UniValue JSONRPCError(int code, const std::string &message)
UniValue JSONRPCReplyObj(UniValue result, UniValue error, std::optional< UniValue > id, JSONRPCVersion jsonrpc_version)
void DeleteAuthCookie()
Delete RPC authentication cookie from disk.
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
@ RPC_CLIENT_NOT_CONNECTED
P2P client errors.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_IN_WARMUP
Client still warming up.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
static const int64_t values[]
A selection of numbers that do not trigger int64_t overflow when added/subtracted.
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
Set the factory function for timer, but only, if unset.
bool IsDeprecatedRPCEnabled(const std::string &method)
void SetRPCWarmupFinished()
static RPCHelpMan uptime()
void RPCUnsetTimerInterface(RPCTimerInterface *iface)
Unset factory function for timers.
static RPCHelpMan getrpcinfo()
void RPCRunLater(const std::string &name, std::function< void()> func, int64_t nSeconds)
Run func nSeconds from now.
static bool ExecuteCommands(const std::vector< const CRPCCommand * > &commands, const JSONRPCRequest &request, UniValue &result)
bool RPCIsInWarmup(std::string *outStatus)
static RPCTimerInterface * timerInterface
static bool ExecuteCommand(const CRPCCommand &command, const JSONRPCRequest &request, UniValue &result, bool last_handler)
static JSONRPCRequest transformNamedArguments(const JSONRPCRequest &in, const std::vector< std::pair< std::string, bool >> &argNames)
Process named arguments into a vector of positional arguments, based on the passed-in specification f...
static std::atomic< bool > g_rpc_running
static GlobalMutex g_deadline_timers_mutex
bool IsRPCRunning()
Query whether RPC is running.
static struct CRPCSignals g_rpcSignals
UniValue JSONRPCExec(const JSONRPCRequest &jreq, bool catch_errors)
static bool fRPCInWarmup GUARDED_BY(g_rpc_warmup_mutex)
static GlobalMutex g_rpc_warmup_mutex
static RPCServerInfo g_rpc_server_info
static const CRPCCommand vRPCCommands[]
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
void RPCSetTimerInterface(RPCTimerInterface *iface)
Set the factory function for timers.
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
NodeContext & EnsureAnyNodeContext(const std::any &context)
boost::signals2::signal< void()> Started
boost::signals2::signal< void()> Stopped
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
bool hidden
For testing only.
RPCCommandExecution(const std::string &method)
std::list< RPCCommandExecutionInfo >::iterator it
SteadyClock::time_point start
@ ANY
Special type to disable type checks (for testing only)
std::list< RPCCommandExecutionInfo > active_commands GUARDED_BY(mutex)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
void UninterruptibleSleep(const std::chrono::microseconds &n)
bilingual_str _(ConstevalStringLiteral str)
Translation function.
const UniValue NullUniValue
std::string Capitalize(std::string str)
Capitalizes the first character of the given string.