Skip to content
Code generator for hashicorp/go-plugin
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.


Go Report Card Build Status Coverage Status

go get -u

plugingen generates code to use arbitrary interfaces with hashicorp's go-plugin, including the use of MuxBroker to support other interfaces as arguments.


plugingen comes with a few caveats:

  • Values that aren't serializable by encoding/gob won't be handled correctly (ignoring interface arguments, which are brokered).
  • Unless told otherwise, plugingen will wrap all errors in plugin.BasicError to ensure they are serialized.
  • All types must be exported so that net/rpc will look at them. This means that the package where the generated code lives will fill with types for function parameters and return values. This is somewhat mitigated by prepending Z_ to generated types, but it's still noisy.
  • plugingen does not generate gRPC plugins. Maybe in the future.

An example

Given the following interface:

type Finder interface {
	Find(string, string) (int, bool)

This tool will generate the following (trimming out type declarations):

// Find implements Find for the Finder interface.
func (c *FinderRPCClient) Find(p0 string, p1 string) (int, bool) {
	params := &Z_Finder_FindParams{
		P0: p0,
		P1: p1,
	results := &Z_Finder_FindResults{}

	if err := c.client.Call("Plugin.Find", params, results); err != nil {
		log.Println("RPC call to Finder.Find failed:", err.Error())

	return results.R0, results.R1

// Find implements the server side of net/rpc calls to Find.
func (s *FinderRPCServer) Find(params *Z_Finder_FindParams, results *Z_Finder_FindResults) error {
	r0, r1 := s.impl.Find(params.P0, params.P1)

	results.R0 = r0
	results.R1 = r1

	return nil

A more complicated example

Take this more complicated interface:

type Processor interface {

This interface requires a function which accepts an io.ReadCloser, which cannot necessarily be serialized. plugingen produces this code to handle the interface:

// Process implements Process for the Processor interface.
func (c *ProcessorRPCClient) Process(p0 io.ReadCloser) {
	p0id :=
	go, NewReadCloserRPCServer(, p0))

	params := &Z_Processor_ProcessParams{P0ID: p0id}
	results := new(interface{})

	if err := c.client.Call("Plugin.Process", params, results); err != nil {
		log.Println("RPC call to Processor.Process failed:", err.Error())

// Process implements the server side of net/rpc calls to Process.
func (s *ProcessorRPCServer) Process(params *Z_Processor_ProcessParams, _ *interface{}) error {
	p0conn, err :=
	if err != nil {
		return err
	p0RPCClient := rpc.NewClient(p0conn)
	defer p0RPCClient.Close()
	p0client := NewReadCloserRPCClient(, p0RPCClient)


	return nil


  • Fix name collisions. If two interfaces are named the same thing, ignoring package names, then the output code will be broken. Interfaces coming from outside packages should include a prefix which summarizes their full name.
  • Support variadic arguments of interfaces. This is technically doable just by inserting a for loop to broker each.
  • Work out some quirks with printing type information. I use Underlying() quite a bit, which results in some cases where names get lost.
  • Allow replacement of net/rpc and hashicorp/go-plugin. net/rpc is frozen, and doesn't have context support (and never will). The "solution" is to use gRPC, but that may pretty massively increase the footprint of this generator (to keep in tune with backwards compatibility), so it may be simpler to allow using a fork of net/rpc like keegancsmith/rpc which allow for context. This would also require maintaining a fork of go-plugin.
  • Testing. This is largely untested.
You can’t perform that action at this time.