Struct clightningrpc_plugin::plugin::Plugin

pub struct Plugin<T>where
    T: 'static + Clone,{
    pub state: T,
    pub option: HashMap<String, RpcOption>,
    pub rpc_method: HashMap<String, Box<dyn RPCCommand<T>>>,
    pub rpc_info: HashSet<RPCMethodInfo>,
    pub rpc_hook: HashMap<String, Box<dyn RPCCommand<T>>>,
    pub hook_info: HashSet<RPCHookInfo>,
    pub rpc_notification: HashMap<String, Box<dyn RPCCommand<T>>>,
    pub dynamic: bool,
    pub configuration: Option<CLNConf>,
    /* private fields */
}

Fields

state: T

option: HashMap<String, RpcOption>

all the option contained inside the hash map.

rpc_method: HashMap<String, Box<dyn RPCCommand<T>>>

all the options rpc method that the plugin need to support, included the builtin rpc method.

rpc_info: HashSet<RPCMethodInfo>

keep the info of the method in a separate list FIXME: move the RPCMethodInfo as key of the rpc_method map.

rpc_hook: HashMap<String, Box<dyn RPCCommand<T>>>

all the hook where the plugin is register during the configuration

hook_info: HashSet<RPCHookInfo>

keep all the info about the hooks in a separate set. FIXME: put the RPCHookInfo as key of the hash map.

rpc_notification: HashMap<String, Box<dyn RPCCommand<T>>>

all the notification that the plugin is register on

dynamic: bool

mark a plugin as dynamic, in this way the plugin can be run from core lightning without stop the lightningd daemon

configuration: Option<CLNConf>

core lightning configuration sent with the init call.

Implementations

impl<'a, T: 'a + Clone> Plugin<T>

pub fn new(state: T, dynamic: bool) -> Self

pub fn on_init(&'a mut self, callback: &'static OnInit<T>) -> Self

pub fn log(&self, level: LogLevel, msg: &str)

pub fn add_opt(
    &mut self,
    name: &str,
    opt_type: &str,
    def_val: Option<String>,
    description: &str,
    deprecated: bool
) -> &mut Self

register the plugin option.

pub fn get_opt<R: for<'de> Deserialize<'de>>(
    &self,
    name: &str
) -> Result<R, PluginError>

get an option value that cln sent back to the plugin.

pub fn add_rpc_method<F>(
    &'a mut self,
    name: &str,
    usage: &str,
    description: &str,
    callback: F
) -> Selfwhere
    F: RPCCommand<T> + 'static,

pub fn register_hook<F>(
    &'a mut self,
    hook_name: &str,
    before: Option<Vec<String>>,
    after: Option<Vec<String>>,
    callback: F
) -> Selfwhere
    F: RPCCommand<T> + 'static,

pub fn register_notification<F>(&mut self, name: &str, callback: F) -> Selfwhere
    F: 'static + RPCCommand<T> + Clone,

pub fn start(self)

Trait Implementations

impl<T> Clone for Plugin<T>where
    T: 'static + Clone + Clone,

fn clone(&self) -> Plugin<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.