mirror of
https://github.com/ElementsProject/lightning.git
synced 2024-11-19 09:54:16 +01:00
plugins: make 'plugin start' 's runtime path independant
This remove the reliance on startup plugins' function "plugin_start" in order to use a distinct runtime path for a dynamically started plugin, which will allow startup plugins' code to be (almost) agnostic of dynamic plugins. This also makes the 'start' subcommand return only if the plugin is either started, or killed : no weird middle state where the plugin mishbehaving could crash lightningd.
This commit is contained in:
darosior
Rusty Russell
parent
603e2f0ca9
commit
edd3ffc7c4
@ -1,13 +1,168 @@
|
||||
#include <ccan/pipecmd/pipecmd.h>
|
||||
#include <ccan/tal/path/path.h>
|
||||
#include <common/json_command.h>
|
||||
#include <common/jsonrpc_errors.h>
|
||||
#include <common/param.h>
|
||||
#include <common/timeout.h>
|
||||
#include <dirent.h>
|
||||
#include <errno.h>
|
||||
#include <lightningd/io_loop_with_timers.h>
|
||||
#include <lightningd/plugin_control.h>
|
||||
#include <lightningd/plugin_hook.h>
|
||||
#include <unistd.h>
|
||||
|
||||
/* A dummy structure used to give multiple arguments to callbacks. */
|
||||
struct dynamic_plugin {
|
||||
struct plugin *plugin;
|
||||
struct command *cmd;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returned by all subcommands on success.
|
||||
*/
|
||||
static struct command_result *plugin_dynamic_list_plugins(struct command *cmd)
|
||||
{
|
||||
struct json_stream *response;
|
||||
struct plugin *p;
|
||||
|
||||
response = json_stream_success(cmd);
|
||||
json_array_start(response, "plugins");
|
||||
list_for_each(&cmd->ld->plugins->plugins, p, list) {
|
||||
json_object_start(response, NULL);
|
||||
json_add_string(response, "name", p->cmd);
|
||||
json_add_bool(response, "active",
|
||||
p->plugin_state == CONFIGURED);
|
||||
json_object_end(response);
|
||||
}
|
||||
json_array_end(response);
|
||||
return command_success(cmd, response);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returned by all subcommands on error.
|
||||
*/
|
||||
static struct command_result *
|
||||
plugin_dynamic_error(struct dynamic_plugin *dp, const char *error)
|
||||
{
|
||||
plugin_kill(dp->plugin, "%s: %s", dp->plugin->cmd, error);
|
||||
return command_fail(dp->cmd, JSONRPC2_INVALID_PARAMS,
|
||||
"%s: %s", dp->plugin->cmd, error);
|
||||
}
|
||||
|
||||
static void plugin_dynamic_timeout(struct dynamic_plugin *dp)
|
||||
{
|
||||
plugin_dynamic_error(dp, "Timed out while waiting for plugin response");
|
||||
}
|
||||
|
||||
static void plugin_dynamic_config_callback(const char *buffer,
|
||||
const jsmntok_t *toks,
|
||||
const jsmntok_t *idtok,
|
||||
struct dynamic_plugin *dp)
|
||||
{
|
||||
struct plugin *p;
|
||||
|
||||
dp->plugin->plugin_state = CONFIGURED;
|
||||
/* Reset the timer only now so that we are either configured, or
|
||||
* killed. */
|
||||
tal_free(dp->plugin->timeout_timer);
|
||||
|
||||
list_for_each(&dp->plugin->plugins->plugins, p, list) {
|
||||
if (p->plugin_state != CONFIGURED)
|
||||
return;
|
||||
}
|
||||
|
||||
/* No plugin unconfigured left, return the plugin list */
|
||||
was_pending(plugin_dynamic_list_plugins(dp->cmd));
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the init message to the plugin. We don't care about its response,
|
||||
* but it's considered the last part of the handshake : once it responds
|
||||
* it is considered configured.
|
||||
*/
|
||||
static void plugin_dynamic_config(struct dynamic_plugin *dp)
|
||||
{
|
||||
struct jsonrpc_request *req;
|
||||
|
||||
req = jsonrpc_request_start(dp->plugin, "init", dp->plugin->log,
|
||||
plugin_dynamic_config_callback, dp);
|
||||
plugin_populate_init_request(dp->plugin, req);
|
||||
jsonrpc_request_end(req);
|
||||
plugin_request_send(dp->plugin, req);
|
||||
}
|
||||
|
||||
static void plugin_dynamic_manifest_callback(const char *buffer,
|
||||
const jsmntok_t *toks,
|
||||
const jsmntok_t *idtok,
|
||||
struct dynamic_plugin *dp)
|
||||
{
|
||||
if (!plugin_parse_getmanifest_response(buffer, toks, idtok, dp->plugin))
|
||||
return was_pending(plugin_dynamic_error(dp, "Gave a bad response to getmanifest"));
|
||||
|
||||
if (!dp->plugin->dynamic)
|
||||
return was_pending(plugin_dynamic_error(dp, "Not a dynamic plugin"));
|
||||
|
||||
/* We got the manifest, now send the init message */
|
||||
plugin_dynamic_config(dp);
|
||||
}
|
||||
|
||||
/**
|
||||
* This starts a plugin : spawns the process, connect its stdout and stdin,
|
||||
* then sends it a getmanifest request.
|
||||
*/
|
||||
static struct command_result *plugin_start(struct dynamic_plugin *dp)
|
||||
{
|
||||
int stdin, stdout;
|
||||
char **p_cmd;
|
||||
struct jsonrpc_request *req;
|
||||
struct plugin *p = dp->plugin;
|
||||
|
||||
p->dynamic = true;
|
||||
p_cmd = tal_arrz(NULL, char *, 2);
|
||||
p_cmd[0] = p->cmd;
|
||||
p->pid = pipecmdarr(&stdin, &stdout, &pipecmd_preserve, p_cmd);
|
||||
if (p->pid == -1)
|
||||
return plugin_dynamic_error(dp, "Error running command");
|
||||
else
|
||||
log_debug(dp->cmd->ld->plugins->log, "started(%u) %s", p->pid, p->cmd);
|
||||
tal_free(p_cmd);
|
||||
p->buffer = tal_arr(p, char, 64);
|
||||
p->stop = false;
|
||||
/* Give the plugin 20 seconds to respond to `getmanifest`, so we don't hang
|
||||
* too long on the RPC caller. */
|
||||
p->timeout_timer = new_reltimer(dp->cmd->ld->timers, dp,
|
||||
time_from_sec(20),
|
||||
plugin_dynamic_timeout, dp);
|
||||
|
||||
/* Create two connections, one read-only on top of the plugin's stdin, and one
|
||||
* write-only on its stdout. */
|
||||
io_new_conn(p, stdout, plugin_stdout_conn_init, p);
|
||||
io_new_conn(p, stdin, plugin_stdin_conn_init, p);
|
||||
req = jsonrpc_request_start(p, "getmanifest", p->log,
|
||||
plugin_dynamic_manifest_callback, dp);
|
||||
jsonrpc_request_end(req);
|
||||
plugin_request_send(p, req);
|
||||
return command_still_pending(dp->cmd);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when trying to start a plugin through RPC, it starts the plugin and
|
||||
* will give a result 20 seconds later at the most.
|
||||
*/
|
||||
static struct command_result *
|
||||
plugin_dynamic_start(struct command *cmd, const char *plugin_path)
|
||||
{
|
||||
struct dynamic_plugin *dp;
|
||||
|
||||
dp = tal(cmd, struct dynamic_plugin);
|
||||
dp->cmd = cmd;
|
||||
dp->plugin = plugin_register(cmd->ld->plugins, plugin_path);
|
||||
if (!dp->plugin)
|
||||
return plugin_dynamic_error(dp, "Is already registered");
|
||||
|
||||
return plugin_start(dp);
|
||||
}
|
||||
|
||||
/**
|
||||
* A plugin command which permits to control plugins without restarting
|
||||
* lightningd. It takes a subcommand, and an optional subcommand parameter.
|
||||
@ -63,7 +218,7 @@ static struct command_result *json_plugin_control(struct command *cmd,
|
||||
return command_param_failed();
|
||||
|
||||
if (access(plugin_path, X_OK) == 0)
|
||||
plugin_register(cmd->ld->plugins, plugin_path);
|
||||
return plugin_dynamic_start(cmd, plugin_path);
|
||||
else
|
||||
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
|
||||
"%s is not executable: %s",
|
||||
@ -98,10 +253,6 @@ static struct command_result *json_plugin_control(struct command *cmd,
|
||||
/* Don't do anything as we return the plugin list anyway */
|
||||
}
|
||||
|
||||
/* The config function is called once we got the manifest,
|
||||
* in 'plugin_manifest_cb'.*/
|
||||
plugins_start(cmd->ld->plugins, cmd->ld->dev_debug_subprocess);
|
||||
|
||||
response = json_stream_success(cmd);
|
||||
json_array_start(response, "plugins");
|
||||
list_for_each(&cmd->ld->plugins->plugins, p, list) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user