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.
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.
This makes two main changes to the plugin system:
* Instead of assuming that each plugin will have exactly one type,
inspect each plugin to see which interfaces it provides, and
register it as a provider of each provided interface. This can
allow a single .so file to provide multiple interfaces, which
will likely be necessary for aggregating certain types of info.
* Rather than using dependency injection and having to propagate
the plugin system all throughout Geth, have a default plugin
loader so we need only import the module and make calls to it.
If the plan were to integrate this into mainline Geth, I would
say we use dependency injection and take the time to pass the
plugin loader throughout the codebase, but as I expect this to
be a fork that has to pull upstream changes, this approach
should make merge conflicts much less common.
