plugeth/plugins/plugin_loader.go

141 lines
3.9 KiB
Go
Raw Normal View History

2021-03-15 20:02:37 +00:00
package plugins
import (
"plugin"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/log"
"gopkg.in/urfave/cli.v1"
"flag"
"io/ioutil"
"strings"
"path"
"fmt"
)
type APILoader func(*node.Node, Backend) []rpc.API
type Subcommand func(*cli.Context, []string) error
type PluginLoader struct{
TracerPlugins map[string]interface{} // TODO: Set interface
StateHooks []interface{} // TODO: Set interface
ChainEventHooks []interface{} // TODO: Set interface
RPCPlugins []APILoader
Subcommands map[string]Subcommand
Flags []*flag.FlagSet
}
var defaultPluginLoader *PluginLoader
2021-03-15 20:02:37 +00:00
func NewPluginLoader(target string) (*PluginLoader, error) {
pl := &PluginLoader{
RPCPlugins: []APILoader{},
Subcommands: make(map[string]Subcommand),
Flags: []*flag.FlagSet{},
}
files, err := ioutil.ReadDir(target)
if err != nil {
log.Warn("Could not load plugins directory. Skipping.", "path", target)
return pl, nil
}
for _, file := range files {
fpath := path.Join(target, file.Name())
if !strings.HasSuffix(file.Name(), ".so") {
log.Debug("File inplugin directory is not '.so' file. Skipping.", "file", fpath)
2021-03-15 20:02:37 +00:00
continue
}
plug, err := plugin.Open(fpath)
if err != nil {
log.Warn("File in plugin directory could not be loaded: %v", "file", fpath, "error", err.Error())
continue
}
// Any type of plugin can potentially specify flags
f, err := plug.Lookup("Flags")
if err == nil {
flagset, ok := f.(*flag.FlagSet)
if !ok {
log.Warn("Found plugin.Flags, but it its not a *FlagSet", "file", fpath)
} else {
pl.Flags = append(pl.Flags, flagset)
}
}
fn, err := plug.Lookup("GetAPIs")
if err == nil {
2021-03-15 20:02:37 +00:00
apiLoader, ok := fn.(func(*node.Node, Backend) []rpc.API)
if !ok {
log.Warn("Could not cast plugin.GetAPIs to APILoader", "file", fpath)
} else {
pl.RPCPlugins = append(pl.RPCPlugins, APILoader(apiLoader))
2021-03-15 20:02:37 +00:00
}
} else { log.Debug("Error retrieving GetAPIs for plugin", "file", fpath, "error", err.Error()) }
sb, err := plug.Lookup("Subcommands")
if err == nil {
subcommands, ok := sb.(map[string]func(*cli.Context, []string) error)
2021-03-15 20:02:37 +00:00
if !ok {
log.Warn("Could not cast plugin.Subocmmands to `map[string]func(*cli.Context, []string) error`", "file", fpath)
} else {
for k, v := range subcommands {
if _, ok := pl.Subcommands[k]; ok {
log.Warn("Subcommand redeclared", "file", fpath, "subcommand", k)
}
pl.Subcommands[k] = v
}
2021-03-15 20:02:37 +00:00
}
}
}
return pl, nil
}
func Initialize(target string) (err error) {
defaultPluginLoader, err = NewPluginLoader(target)
return err
}
2021-03-15 20:02:37 +00:00
func (pl *PluginLoader) RunSubcommand(ctx *cli.Context) (bool, error) {
args := ctx.Args()
if len(args) == 0 { return false, fmt.Errorf("No subcommand arguments")}
subcommand, ok := pl.Subcommands[args[0]]
if !ok { return false, fmt.Errorf("Subcommand %v does not exist", args[0])}
return true, subcommand(ctx, args[1:])
}
func RunSubcommand(ctx *cli.Context) (bool, error) {
if defaultPluginLoader == nil { return false, fmt.Errorf("Plugin loader not initialized") }
return defaultPluginLoader.RunSubcommand(ctx)
}
2021-03-15 20:02:37 +00:00
func (pl *PluginLoader) ParseFlags(args []string) bool {
for _, flagset := range pl.Flags {
flagset.Parse(args)
}
return len(pl.Flags) > 0
}
func ParseFlags(args []string) bool {
if defaultPluginLoader == nil {
log.Warn("Attempting to parse flags, but default PluginLoader has not been initialized")
return false
}
return defaultPluginLoader.ParseFlags(args)
}
2021-03-15 20:02:37 +00:00
func (pl *PluginLoader) GetAPIs(stack *node.Node, backend Backend) []rpc.API {
apis := []rpc.API{}
for _, apiLoader := range pl.RPCPlugins {
apis = append(apis, apiLoader(stack, backend)...)
}
return apis
}
func GetAPIs(stack *node.Node, backend Backend) []rpc.API {
if defaultPluginLoader == nil {
log.Warn("Attempting GetAPIs ,but default PluginLoader has not been initialized")
return []rpc.API{}
}
return defaultPluginLoader.GetAPIs(stack, backend)
}