Checkpoint

Things are currently broken because of import cycles. I'm going to need to revisit how the plugin loader works, but I wanted to make a checkpoint before I start breaking things again.
2021-06-25 17:08:39 -05:00
parent ad8719a64a
commit 091a2f4884
6 changed files with 346 additions and 109 deletions
@@ -2,11 +2,15 @@ package plugins

 import (
 	"plugin"
-	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
+	// "github.com/ethereum/go-ethereum/eth/ethconfig"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
 	"gopkg.in/urfave/cli.v1"
 	"flag"
 	"io/ioutil"
@@ -17,7 +21,6 @@ import (
 )


-type APILoader func(*node.Node, Backend) []rpc.API
 type Subcommand func(*cli.Context, []string) error
 type TracerResult interface {
 	vm.Tracer
@@ -26,29 +29,42 @@ type TracerResult interface {


 type PluginLoader struct{
-	Tracers map[string]func(*state.StateDB)TracerResult
+	Plugins []plugin.Plugin
+	Tracers map[string]func(StateDB)TracerResult
 	StateHooks []interface{} // TODO: Set interface
-	ChainEventHooks []interface{} // TODO: Set interface
-	RPCPlugins []APILoader
+	// RPCPlugins []APILoader
 	Subcommands map[string]Subcommand
 	Flags []*flag.FlagSet
+	CreateConsensusEngine func(stack *node.Node, chainConfig *params.ChainConfig, config *ethash.Config, notify []string, noverify bool, db ethdb.Database) consensus.Engine
+	UpdateBlockchainVMConfig func(*vm.Config)
+	PreProcessBlockList []func(*types.Block)
+	PreProcessTransactionList []func(*types.Transaction, *types.Block, int)
+	BlockProcessingErrorList []func(*types.Transaction, *types.Block, error)
+	PostProcessTransactionList []func(*types.Transaction, *types.Block, int, *types.Receipt)
+	PostProcessBlockList []func(*types.Block)
 }

-var defaultPluginLoader *PluginLoader
+
+var DefaultPluginLoader *PluginLoader


 func NewPluginLoader(target string) (*PluginLoader, error) {
 	pl := &PluginLoader{
-		RPCPlugins: []APILoader{},
+		Plugins: []plugin.Plugin,
+		// RPCPlugins: []APILoader{},
 		Subcommands: make(map[string]Subcommand),
-		Tracers: make(map[string]func(*state.StateDB)TracerResult),
+		Tracers: make(map[string]func(StateDB)TracerResult),
 		Flags: []*flag.FlagSet{},
+		// CreateConsensusEngine: ethconfig.CreateConsensusEngine,
+		UpdateBlockchainVMConfig: func(cfg *vm.Config) {},
 	}
 	files, err := ioutil.ReadDir(target)
 	if err != nil {
 		log.Warn("Could not load plugins directory. Skipping.", "path", target)
 		return pl, nil
 	}
+	setConsensus := false
+	setUpdateBCVMCfg := false
 	for _, file := range files {
 		fpath := path.Join(target, file.Name())
 		if !strings.HasSuffix(file.Name(), ".so") {
@@ -70,16 +86,6 @@ func NewPluginLoader(target string) (*PluginLoader, error) {
 				pl.Flags = append(pl.Flags, flagset)
 			}
 		}
-		fn, err := plug.Lookup("GetAPIs")
-		if err == nil {
-			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))
-			}
-		} 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)
@@ -96,7 +102,7 @@ func NewPluginLoader(target string) (*PluginLoader, error) {
 		}
 		tr, err := plug.Lookup("Tracers")
 		if err == nil {
-			tracers, ok := tr.(*map[string]func(*state.StateDB)TracerResult)
+			tracers, ok := tr.(*map[string]func(StateDB)TracerResult)
 			if !ok {
 				log.Warn("Could not cast plugin.Tracers to `map[string]vm.Tracer`", "file", fpath)
 			} else {
@@ -108,12 +114,89 @@ func NewPluginLoader(target string) (*PluginLoader, error) {
 				}
 			}
 		}
+		ce, err := plug.Lookup("CreateConsensusEngine")
+		if err == nil {
+			cce, ok := ce.(func (stack *node.Node, chainConfig *params.ChainConfig, config *ethash.Config, notify []string, noverify bool, db ethdb.Database) consensus.Engine)
+			if !ok {
+				log.Warn("Could not cast plugin.CreateConsensusEngine to appropriate function", "file", fpath)
+			} else {
+				if setConsensus {
+					log.Warn("CreateConsensusEngine redeclared", "file", fpath)
+				}
+				pl.CreateConsensusEngine = cce
+				setConsensus = true
+			}
+		}
+		vmcfgu, err := plug.Lookup("UpdateBlockchainVMConfig")
+		if err == nil {
+			vmcfgfn, ok := vmcfgu.(func(*vm.Config))
+			if !ok {
+				log.Warn("Could not cast plugin.UpdateBlockchainVMConfig to appropriate function", "file", fpath)
+			} else {
+				if setUpdateBCVMCfg {
+					log.Warn("UpdateBlockchainVMConfig redeclared", "file", fpath)
+				}
+				pl.UpdateBlockchainVMConfig = vmcfgfn
+				setUpdateBCVMCfg = true
+			}
+		}
+
+
+		prepb, err := plug.Lookup("PreProcessBlock")
+		if err == nil {
+			prepbfn, ok := prepb.(func(*types.Block))
+			if !ok {
+				log.Warn("Could not cast plugin.PreProcessBlock to appropriate function", "file", fpath)
+			} else {
+				pl.PreProcessBlockList = append(pl.PreProcessBlockList, prepbfn)
+			}
+		}
+		prept, err := plug.Lookup("PreProcessTransaction")
+		if err == nil {
+			preptfn, ok := prept.(func(*types.Transaction, *types.Block, int))
+			if !ok {
+				log.Warn("Could not cast plugin.PreProcessTransaction to appropriate function", "file", fpath)
+			} else {
+				pl.PreProcessTransactionList = append(pl.PreProcessTransactionList, preptfn)
+			}
+		}
+		bpe, err := plug.Lookup("BlockProcessingError")
+		if err == nil {
+			bpefn, ok := bpe.(func(*types.Transaction, *types.Block, error))
+			if !ok {
+				log.Warn("Could not cast plugin.BlockProcessingError to appropriate function", "file", fpath)
+			} else {
+				pl.BlockProcessingErrorList = append(pl.BlockProcessingErrorList, bpefn)
+			}
+		}
+		prept, err := plug.Lookup("PostProcessTransaction")
+		if err == nil {
+			preptfn, ok := prept.(func(*types.Transaction, *types.Block, int, *types.Receipt))
+			if !ok {
+				log.Warn("Could not cast plugin.PostProcessTransaction to appropriate function", "file", fpath)
+			} else {
+				pl.PostProcessTransactionList = append(pl.PostProcessTransactionList, preptfn)
+			}
+		}
+		prepb, err := plug.Lookup("PostProcessBlock")
+		if err == nil {
+			prepbfn, ok := prepb.(func(*types.Block))
+			if !ok {
+				log.Warn("Could not cast plugin.PostProcessBlock to appropriate function", "file", fpath)
+			} else {
+				pl.PostProcessBlockList = append(pl.PostProcessBlockList, prepbfn)
+			}
+		}
+
+
+
+
 	}
 	return pl, nil
 }

 func Initialize(target string) (err error) {
-	defaultPluginLoader, err = NewPluginLoader(target)
+	DefaultPluginLoader, err = NewPluginLoader(target)
 	return err
 }

@@ -126,8 +209,8 @@ func (pl *PluginLoader) RunSubcommand(ctx *cli.Context) (bool, error) {
 }

 func RunSubcommand(ctx *cli.Context) (bool, error) {
-	if defaultPluginLoader == nil { return false, fmt.Errorf("Plugin loader not initialized") }
-	return defaultPluginLoader.RunSubcommand(ctx)
+	if DefaultPluginLoader == nil { return false, fmt.Errorf("Plugin loader not initialized") }
+	return DefaultPluginLoader.RunSubcommand(ctx)
 }

 func (pl *PluginLoader) ParseFlags(args []string) bool {
@@ -138,38 +221,100 @@ func (pl *PluginLoader) ParseFlags(args []string) bool {
 }

 func ParseFlags(args []string) bool {
-	if defaultPluginLoader == nil {
+	if DefaultPluginLoader == nil {
 		log.Warn("Attempting to parse flags, but default PluginLoader has not been initialized")
 		return false
 	}
-	return defaultPluginLoader.ParseFlags(args)
+	return DefaultPluginLoader.ParseFlags(args)
 }

-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)
-}
-
-func (pl *PluginLoader) GetTracer(s string) (func(*state.StateDB)TracerResult, bool) {
+func (pl *PluginLoader) GetTracer(s string) (func(StateDB)TracerResult, bool) {
 	tr, ok := pl.Tracers[s]
 	return tr, ok
 }

-func GetTracer(s string) (func(*state.StateDB)TracerResult, bool) {
-	if defaultPluginLoader == nil {
+func GetTracer(s string) (func(StateDB)TracerResult, bool) {
+	if DefaultPluginLoader == nil {
 		log.Warn("Attempting GetTracer, but default PluginLoader has not been initialized")
 		return nil, false
 	}
-	return defaultPluginLoader.GetTracer(s)
+	return DefaultPluginLoader.GetTracer(s)
+}
+
+// func CreateConsensusEngine(stack *node.Node, chainConfig *params.ChainConfig, config *ethash.Config, notify []string, noverify bool, db ethdb.Database) consensus.Engine {
+// 	if DefaultPluginLoader == nil {
+// 		log.Warn("Attempting CreateConsensusEngine, but default PluginLoader has not been initialized")
+// 		return ethconfig.CreateConsensusEngine(stack, chainConfig, config, notify, noverify, db)
+// 	}
+// 	return DefaultPluginLoader.CreateConsensusEngine(stack, chainConfig, config, notify, noverify, db)
+// }
+
+func UpdateBlockchainVMConfig(cfg *vm.Config) {
+	if DefaultPluginLoader == nil {
+		log.Warn("Attempting UpdateBlockchainVMConfig, but default PluginLoader has not been initialized")
+		return
+	}
+	DefaultPluginLoader.UpdateBlockchainVMConfig(cfg)
+}
+
+
+func (pl *PluginLoader) PreProcessBlock(block *types.Block) {
+	for _, fn := range pl.PreProcessBlockList {
+		fn(block)
+	}
+}
+func PreProcessBlock(block *types.Block) {
+	if DefaultPluginLoader == nil {
+		log.Warn("Attempting PreProcessBlock, but default PluginLoader has not been initialized")
+		return
+	}
+	DefaultPluginLoader.PreProcessBlock(block)
+}
+func (pl *PluginLoader) PreProcessTransaction(tx *types.Transaction, block *types.Block, i int) {
+	for _, fn := range pl.PreProcessTransactionList {
+		fn(tx, block, i)
+	}
+}
+func PreProcessTransaction(tx *types.Transaction, block *types.Block, i int) {
+	if DefaultPluginLoader == nil {
+		log.Warn("Attempting PreProcessTransaction, but default PluginLoader has not been initialized")
+		return
+	}
+	DefaultPluginLoader.PreProcessTransaction(tx, block, i)
+}
+func (pl *PluginLoader) BlockProcessingError(tx *types.Transaction, block *types.Block, err error) {
+	for _, fn := range pl.BlockProcessingErrorList {
+		fn(tx, block, err)
+	}
+}
+func BlockProcessingError(tx *types.Transaction, block *types.Block, err error) {
+	if DefaultPluginLoader == nil {
+		log.Warn("Attempting BlockProcessingError, but default PluginLoader has not been initialized")
+		return
+	}
+	DefaultPluginLoader.BlockProcessingError(tx, block, err)
+}
+func (pl *PluginLoader) PostProcessTransaction(tx *types.Transaction, block *types.Block, i int, receipt *types.Receipt) {
+	for _, fn := range pl.PostProcessTransactionList {
+		fn(tx, block, i, receipt)
+	}
+}
+func PostProcessTransaction(tx *types.Transaction, block *types.Block, i int, receipt *types.Receipt) {
+	if DefaultPluginLoader == nil {
+		log.Warn("Attempting PostProcessTransaction, but default PluginLoader has not been initialized")
+		return
+	}
+	DefaultPluginLoader.PostProcessTransaction(tx, block, i, receipt)
+}
+func (pl *PluginLoader) PostProcessBlock(block *types.Block) {
+	for _, fn := range pl.PostProcessBlockList {
+		fn(block)
+	}
+}
+func PostProcessBlock(block *types.Block) {
+	if DefaultPluginLoader == nil {
+		log.Warn("Attempting PostProcessBlock, but default PluginLoader has not been initialized")
+		return
+	}
+	DefaultPluginLoader.PostProcessBlock(block)
 }