refactor: plugin functions can be defined in any format

plugin/shared/config.go

@@ -0,0 +1,15 @@
+package shared
+
+import "github.com/hashicorp/go-plugin"
+
+const Name = "debugtalk"
+
+// handshakeConfigs are used to just do a basic handshake between
+// a plugin and host. If the handshake fails, a user friendly error is shown.
+// This prevents users from executing bad plugins or executing a plugin
+// directory. It is a UX feature, not a security feature.
+var HandshakeConfig = plugin.HandshakeConfig{
+	ProtocolVersion:  1,
+	MagicCookieKey:   "HttpRunnerPlus",
+	MagicCookieValue: Name,
+}

plugin/shared/interface.go

@@ -0,0 +1,103 @@
+package shared
+
+import (
+	"encoding/gob"
+	"net/rpc"
+
+	"github.com/hashicorp/go-plugin"
+	"github.com/rs/zerolog/log"
+)
+
+func init() {
+	gob.Register(new(funcData))
+}
+
+// funcData is used to transfer between plugin and host via RPC.
+type funcData struct {
+	Name string        // function name
+	Args []interface{} // function arguments
+}
+
+// FuncCaller is the interface that we're exposing as a plugin.
+type FuncCaller interface {
+	GetNames() ([]string, error)                                    // get all plugin function names list
+	Call(funcName string, args ...interface{}) (interface{}, error) // call plugin function
+}
+
+// functionRPC runs on the host side.
+type functionRPC struct {
+	client *rpc.Client
+}
+
+func (g *functionRPC) GetNames() ([]string, error) {
+	var resp []string
+	err := g.client.Call("Plugin.GetNames", new(interface{}), &resp)
+	if err != nil {
+		log.Error().Err(err).Msg("rpc call GetNames() failed")
+		return nil, err
+	}
+	return resp, nil
+}
+
+// host -> plugin
+func (g *functionRPC) Call(funcName string, funcArgs ...interface{}) (interface{}, error) {
+	log.Info().Str("funcName", funcName).Interface("funcArgs", funcArgs).Msg("call function via RPC")
+	f := funcData{
+		Name: funcName,
+		Args: funcArgs,
+	}
+
+	var args interface{} = f
+	var resp interface{}
+	err := g.client.Call("Plugin.Call", &args, &resp)
+	if err != nil {
+		log.Error().Err(err).
+			Str("funcName", funcName).Interface("funcArgs", funcArgs).
+			Msg("rpc call Call() failed")
+		return nil, err
+	}
+	return resp, nil
+}
+
+// functionRPCServer runs on the plugin side, executing the user custom function.
+type functionRPCServer struct {
+	Impl FuncCaller
+}
+
+// plugin execution
+func (s *functionRPCServer) GetNames(args interface{}, resp *[]string) error {
+	log.Info().Interface("args", args).Msg("GetNames called on plugin side")
+	var err error
+	*resp, err = s.Impl.GetNames()
+	if err != nil {
+		log.Error().Err(err).Msg("GetNames execution failed")
+		return err
+	}
+	return nil
+}
+
+// plugin execution
+func (s *functionRPCServer) Call(args interface{}, resp *interface{}) error {
+	log.Info().Interface("args", args).Msg("function called on plugin side")
+	f := args.(*funcData)
+	var err error
+	*resp, err = s.Impl.Call(f.Name, f.Args...)
+	if err != nil {
+		log.Error().Err(err).Interface("args", args).Msg("function execution failed")
+		return err
+	}
+	return nil
+}
+
+// HashicorpPlugin implements hashicorp's plugin.Plugin.
+type HashicorpPlugin struct {
+	Impl FuncCaller
+}
+
+func (p *HashicorpPlugin) Server(*plugin.MuxBroker) (interface{}, error) {
+	return &functionRPCServer{Impl: p.Impl}, nil
+}
+
+func (HashicorpPlugin) Client(b *plugin.MuxBroker, c *rpc.Client) (interface{}, error) {
+	return &functionRPC{client: c}, nil
+}

plugin/shared/utils.go

@@ -0,0 +1,50 @@
+package shared
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// CallFunc calls function with arguments
+// it is used when calling go plugin or builtin functions
+func CallFunc(fn reflect.Value, args ...interface{}) (interface{}, error) {
+	fnArgsNum := fn.Type().NumIn()
+	if fnArgsNum > 0 && fn.Type().In(fnArgsNum-1).Kind() == reflect.Slice {
+		// last argument is slice, do not check arguments number
+		// e.g. ...interface{}
+		// e.g. a, b string, c ...interface{}
+	} else if fnArgsNum != len(args) {
+		// function arguments not match
+		return nil, fmt.Errorf("function arguments number not match, expect %d, got %d", fnArgsNum, len(args))
+	}
+	// arguments do not have slice, and arguments number matched
+
+	argumentsValue := make([]reflect.Value, len(args))
+	for index, argument := range args {
+		if argument == nil {
+			argumentsValue[index] = reflect.Zero(fn.Type().In(index))
+		} else {
+			argumentsValue[index] = reflect.ValueOf(args[index])
+		}
+	}
+
+	resultValues := fn.Call(argumentsValue)
+	if resultValues == nil {
+		// no returns
+		return nil, nil
+	} else if len(resultValues) == 2 {
+		// return two arguments: interface{}, error
+		if resultValues[1].Interface() != nil {
+			return resultValues[0].Interface(), resultValues[1].Interface().(error)
+		} else {
+			return resultValues[0].Interface(), nil
+		}
+	} else if len(resultValues) == 1 {
+		// return one arguments: interface{}
+		return resultValues[0].Interface(), nil
+	} else {
+		// return more than 2 arguments, unexpected
+		err := fmt.Errorf("function should return at most 2 arguments")
+		return nil, err
+	}
+}