plugin

type Broker ¶ added in v3.1.9

type Broker interface {
	NextId() uint32
	AcceptAndServe(id uint32, s func([]grpc.ServerOption) *grpc.Server)
}

type Config ¶

type Config map[string]string

Config holds a map of the plugin configuration data structure.

type Executor ¶

type Executor interface {
	Execute(args *types.ExecuteRequest, cb StatusHelper) (*types.ExecuteResponse, error)
}

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

type ExecutorClient ¶

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

Here is the gRPC client that GRPCClient talks to.

func (m *ExecutorClient) Execute(args *types.ExecuteRequest, cb StatusHelper) (*types.ExecuteResponse, error)

type ExecutorPlugin ¶

type ExecutorPlugin struct {
	plugin.NetRPCUnsupportedPlugin
	Executor Executor
}

This is the implementation of plugin.Plugin so we can serve/consume this. We also implement GRPCPlugin so that this plugin can be served over gRPC.

func (p *ExecutorPlugin) GRPCClient(ctx context.Context, broker *plugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error)

func (p *ExecutorPlugin) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error

type ExecutorPluginConfig ¶

type ExecutorPluginConfig map[string]string

ExecutorPluginConfig is the plugin config

type ExecutorServer ¶

type ExecutorServer struct {
	// This is the real implementation
	types.ExecutorServer
	Impl Executor
	// contains filtered or unexported fields
}

Here is the gRPC server that GRPCClient talks to.

func (m ExecutorServer) Execute(ctx context.Context, req *types.ExecuteRequest) (*types.ExecuteResponse, error)

type GRPCStatusHelperClient ¶

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

GRPCStatusHelperClient is an implementation of status updates over RPC.

func (m *GRPCStatusHelperClient) Update(b []byte, c bool) (int64, error)

type GRPCStatusHelperServer ¶

type GRPCStatusHelperServer struct {
	// This is the real implementation
	types.StatusHelperServer
	Impl StatusHelper
}

GRPCStatusHelperServer is the gRPC server that GRPCClient talks to.

func (m *GRPCStatusHelperServer) Update(ctx context.Context, req *types.StatusUpdateRequest) (resp *types.StatusUpdateResponse, err error)

type Processor ¶

type Processor interface {
	// Main plugin method, will be called when an execution is done.
	Process(args *ProcessorArgs) types.Execution
}

Processor is an interface that wraps the Process method. Plugins must implement this interface.

type ProcessorArgs ¶

type ProcessorArgs struct {
	// The execution to pass to the processor
	Execution types.Execution
	// The configuration for this plugin call
	Config Config
}

ProcessorArgs holds the Execution and PluginConfig for a Processor.

type ProcessorClient ¶

type ProcessorClient struct {
	Broker *plugin.MuxBroker
	Client *rpc.Client
}

ProcessorClient is an implementation that talks over RPC

func (e *ProcessorClient) Process(args *ProcessorArgs) types.Execution

type ProcessorPlugin ¶

type ProcessorPlugin struct {
	Processor Processor
}

ProcessorPlugin RPC implementation

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

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

type ProcessorServer ¶

type ProcessorServer struct {
	// This is the real implementation
	Broker    *plugin.MuxBroker
	Processor Processor
}

ProcessorServer is the RPC server that client talks to, conforming to the requirements of net/rpc

func (e *ProcessorServer) Process(args *ProcessorArgs, resp *types.Execution) error

type ServeOpts ¶

type ServeOpts struct {
	Processor Processor
	Executor  Executor
}

ServeOpts are the configurations to serve a plugin.

type StatusHelper ¶

type StatusHelper interface {
	Update([]byte, bool) (int64, error)
}