cerc-io/plugeth
18
0
Fork 1
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity
16cc5314cf
plugeth/cmd/geth/plugin_hooks.go

54 lines
1.7 KiB
Go
Raw Normal View History

Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
package main
import (
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/plugins"
Fix tracer loading
2021-06-26 04:27:09 +00:00
"github.com/ethereum/go-ethereum/plugins/interfaces"
Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/log"
)
Fix tracer loading
2021-06-26 04:27:09 +00:00
type APILoader func(*node.Node, interfaces.Backend) []rpc.API
Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
Fix tracer loading
2021-06-26 04:27:09 +00:00
func GetAPIsFromLoader(pl *plugins.PluginLoader, stack *node.Node, backend interfaces.Backend) []rpc.API {
Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
result := []rpc.API{}
fnList := pl.Lookup("GetAPIs", func(item interface{}) bool {
Fix tracer loading
2021-06-26 04:27:09 +00:00
_, ok := item.(func(*node.Node, interfaces.Backend) []rpc.API)
Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
return ok
})
for _, fni := range fnList {
Fix tracer loading
2021-06-26 04:27:09 +00:00
if fn, ok := fni.(func(*node.Node, interfaces.Backend) []rpc.API); ok {
Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
result = append(result, fn(stack, backend)...)
}
}
return result
}
Fix tracer loading
2021-06-26 04:27:09 +00:00
func pluginGetAPIs(stack *node.Node, backend interfaces.Backend) []rpc.API {
Refactor plugin system When the plugin loader itself had to know the types in the arguments and return values of the plugin functions, it was very difficult to avoid import loops, given that the types were often defined in the same package that needed to invoke the plugins. Under this model, the plugin loader has much less knowledge of the plugins themselves, and within each package we define functions to interact with the plugins.
2021-06-26 03:38:04 +00:00
if plugins.DefaultPluginLoader == nil {
log.Warn("Attempting GetAPIs, but default PluginLoader has not been initialized")
return []rpc.API{}
}
return GetAPIsFromLoader(plugins.DefaultPluginLoader, stack, backend)
}
Add state update hooks
2021-07-12 19:45:42 +00:00
func InitializeNode(pl *plugins.PluginLoader, stack *node.Node, backend interfaces.Backend) {
fnList := pl.Lookup("InitializeNode", func(item interface{}) bool {
_, ok := item.(func(*node.Node, interfaces.Backend))
return ok
})
for _, fni := range fnList {
if fn, ok := fni.(func(*node.Node, interfaces.Backend)); ok {
fn(stack, backend)
}
}
}
func pluginsInitializeNode(stack *node.Node, backend interfaces.Backend) {
if plugins.DefaultPluginLoader == nil {
log.Warn("Attempting InitializeNode, but default PluginLoader has not been initialized")
return
}
InitializeNode(plugins.DefaultPluginLoader, stack, backend)
}
Reference in New Issue Copy Permalink