Node diagnostics, test controls and index status

251                        }},
252                    {"exclude", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The categories to remove from debug logging",
253                        {
254                            {"exclude_category", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "the valid logging category"},
255                        }},
256                },
257                RPCResult{
258                    RPCResult::Type::OBJ_DYN, "", "keys are the logging categories, and values indicates its status",
259                    {
260                        {RPCResult::Type::BOOL, "category", "if being debug logged or not. false:inactive, true:active"},
261                    }
262                },
263                RPCExamples{
264                    HelpExampleCli("logging", "\"[\\\"all\\\"]\" \"[\\\"http\\\"]\"")
265            + HelpExampleRpc("logging", "[\"all\"], [\"leveldb\"]")
266                },
267        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
268{
269    if (request.params[0].isArray()) {
270        EnableOrDisableLogCategories(request.params[0], true);
271    }
272    if (request.params[1].isArray()) {
273        EnableOrDisableLogCategories(request.params[1], false);
274    }
275
276    UniValue result(UniValue::VOBJ);
277    for (const auto& logCatActive : LogInstance().LogCategoriesList()) {
278        result.pushKV(logCatActive.category, logCatActive.active);
279    }
280
281    return result;
282},
283    };
284}
285
286static RPCMethod echo(const std::string& name)
287{
288    return RPCMethod{
289        name,
290        "Simply echo back the input arguments. This command is for testing.\n"
291                "\nIt will return an internal bug report when arg9='trigger_internal_bug' is passed.\n"
292                "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
293                "bitcoin-cli and the GUI. There is no server-side difference.",
294        {
295            {"arg0", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
296            {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
297            {"arg2", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
298            {"arg3", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
299            {"arg4", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
300            {"arg5", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
301            {"arg6", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
302            {"arg7", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
303            {"arg8", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
304            {"arg9", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
305        },
306                RPCResult{RPCResult::Type::ANY, "", "Returns whatever was passed in"},
307                RPCExamples{""},
308        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
309{
310    if (request.params[9].isStr()) {
311        CHECK_NONFATAL(request.params[9].get_str() != "trigger_internal_bug");
312    }
313
314    return request.params;
315},
316    };
317}
318
319static RPCMethod echo() { return echo("echo"); }
320static RPCMethod echojson() { return echo("echojson"); }
321
322static RPCMethod echoipc()
323{
324    return RPCMethod{
325        "echoipc",
326        "Echo back the input argument, passing it through a spawned process in a multiprocess build.\n"
327        "This command is for testing.\n",
328        {{"arg", RPCArg::Type::STR, RPCArg::Optional::NO, "The string to echo",}},
329        RPCResult{RPCResult::Type::STR, "echo", "The echoed string."},
330        RPCExamples{HelpExampleCli("echo", "\"Hello world\"") +
331                    HelpExampleRpc("echo", "\"Hello world\"")},
332        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue {
333            interfaces::Init& local_init = *EnsureAnyNodeContext(request.context).init;
334            std::unique_ptr<interfaces::Echo> echo;
335            if (interfaces::Ipc* ipc = local_init.ipc()) {
336                // Spawn a new bitcoin-node process and call makeEcho to get a
337                // client pointer to a interfaces::Echo instance running in
338                // that process. This is just for testing. A slightly more
339                // realistic test spawning a different executable instead of
340                // the same executable would add a new bitcoin-echo executable,
341                // and spawn bitcoin-echo below instead of bitcoin-node. But
342                // using bitcoin-node avoids the need to build and install a
343                // new executable just for this one test.
344                auto init = ipc->spawnProcess("bitcoin-node");
345                echo = init->makeEcho();
346                ipc->addCleanup(*echo, [init = init.release()] { delete init; });
347            } else {
348                // IPC support is not available because this is a bitcoind
349                // process not a bitcoind-node process, so just create a local
350                // interfaces::Echo object and return it so the `echoipc` RPC
351                // method will work, and the python test calling `echoipc`
352                // can expect the same result.
353                echo = local_init.makeEcho();
354            }
355            return echo->echo(request.params[0].get_str());
356        },
357    };
358}
359
360static UniValue SummaryToJSON(const IndexSummary&& summary, std::string index_name)
361{
362    UniValue ret_summary(UniValue::VOBJ);
363    if (!index_name.empty() && index_name != summary.name) return ret_summary;
364
365    UniValue entry(UniValue::VOBJ);
366    entry.pushKV("synced", summary.synced);
367    entry.pushKV("best_block_height", summary.best_block_height);
368    ret_summary.pushKV(summary.name, std::move(entry));
369    return ret_summary;
370}
371
372static RPCMethod getindexinfo()
373{
374    return RPCMethod{
375        "getindexinfo",
376        "Returns the status of one or all available indices currently running in the node.\n",
377                {
378                    {"index_name", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter results for an index with a specific name."},
379                },
380                RPCResult{
381                    RPCResult::Type::OBJ_DYN, "", "", {
382                        {
383                            RPCResult::Type::OBJ, "name", "The name of the index",
384                            {
385                                {RPCResult::Type::BOOL, "synced", "Whether the index is synced or not"},
386                                {RPCResult::Type::NUM, "best_block_height", "The block height to which the index is synced"},
387                            }
388                        },
389                    },
390                },
391                RPCExamples{
392                    HelpExampleCli("getindexinfo", "")
393                  + HelpExampleRpc("getindexinfo", "")
394                  + HelpExampleCli("getindexinfo", "txindex")
395                  + HelpExampleRpc("getindexinfo", R"("txindex")")
396                },
397                [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
398{
399    UniValue result(UniValue::VOBJ);
400    const std::string index_name{self.MaybeArg<std::string_view>("index_name").value_or("")};
401
402    if (g_txindex) {
403        result.pushKVs(SummaryToJSON(g_txindex->GetSummary(), index_name));
404    }
405
406    if (g_coin_stats_index) {
407        result.pushKVs(SummaryToJSON(g_coin_stats_index->GetSummary(), index_name));
408    }
409
410    if (g_txospenderindex) {
411        result.pushKVs(SummaryToJSON(g_txospenderindex->GetSummary(), index_name));
412    }
413
414    ForEachBlockFilterIndex([&result, &index_name](const BlockFilterIndex& index) {
415        result.pushKVs(SummaryToJSON(index.GetSummary(), index_name));
416    });
417
418    return result;
419},
420    };
421}
422
423void RegisterNodeRPCCommands(CRPCTable& t)
424{
425    static const CRPCCommand commands[]{
426        {"control", &getmemoryinfo},
427        {"control", &logging},
428        {"util", &getindexinfo},
429        {"hidden", &setmocktime},
430        {"hidden", &mockscheduler},
431        {"hidden", &echo},
432        {"hidden", &echojson},
433        {"hidden", &echoipc},
434    };
435    for (const auto& c : commands) {
436        t.appendCommand(c.name, &c);
437    }
438}
439