shared

type CustomPlugin ¶

type CustomPlugin struct {
	// CustomPlugin must still implement the Plugin interface
	plugin.Plugin
	// Concrete implementation, written in Go. This is only used for plugins
	// that are written in Go.
	Impl Service
}

CustomPlugin This is the implementation of plugin.Plugin so we can serve/consume this

This has two methods: Server must return an RPC server for this plugin type. We construct a GreeterRPCServer for this.

Client must return an implementation of our interface that communicates over an RPC client. We return GreeterRPC for this.

Ignore MuxBroker. That is used to create more multiplexed streams on our plugin connection and is a more advanced use case.

func (CustomPlugin) Client(b *plugin.MuxBroker, c *rpc.Client) (interface{}, error)

func (p *CustomPlugin) Server(*plugin.MuxBroker) (interface{}, error)

type LogrusInfo ¶

type LogrusInfo struct {
	// Version is injected by go (should be a tag name)
	Version string
	// Buildstamp is a timestamp (injected by go) of the build time
	Buildstamp string
	// Githash is the tag for current hash the build represents
	Githash string
}

type PluginRPC ¶

type PluginRPC struct {
	// contains filtered or unexported fields
}

PluginRPC is an implementation that talks over RPC

type PluginRPCServer ¶

type PluginRPCServer struct {
	// This is the real implementation
	Impl Service
}

PluginRPCServer is the RPC server that GreeterRPC talks to, conforming to the requirements of net/rpc

func (s *PluginRPCServer) Start(args interface{}, resp *string) error

type Service ¶

type Service interface {
	Start()
	Stop()
}

Service is the interface that we're exposing as a plugin.