fea: grpc.Plugin & grpc.Serve

Author: trheyi

go.mod

@@ -5,7 +5,7 @@ go 1.16
 require (
 	github.com/TylerBrock/colorjson v0.0.0-20200706003622-8a50f05110d2
 	github.com/fatih/color v1.12.0
-	github.com/hashicorp/go-hclog v0.16.2 // indirect
+	github.com/hashicorp/go-hclog v0.16.2
 	github.com/hashicorp/go-plugin v1.4.2
 	github.com/hashicorp/yamux v0.0.0-20210707203944-259a57b3608c // indirect
 	github.com/hokaccha/go-prettyjson v0.0.0-20210113012101-fb4e108d2519 // indirect

grpc/README.md

@@ -0,0 +1,13 @@
+# GRPC Plugin
+
+## Updating the Protocol
+
+If you update the protocol buffers file, you can regenerate the file using the following command from this directory. You do not need to run this if you're just trying the example.
+
+```bash
+protoc -I proto/ proto/model.proto  --go_out=plugins=grpc:proto/
+```
+
+## More
+
+https://github.com/hashicorp/go-plugin/tree/master/examples/grpc

grpc/grpc.go

@@ -26,7 +26,7 @@ func (m *ClientGRPC) Exec(name string, args ...interface{}) (*Response, error) {
 		return nil, err
 	}
 
-	return &Response{Bytes: res.Response}, nil
+	return &Response{Bytes: res.Response, Type: res.Type}, nil
 }
 
 // ServerGRPC Here is the gRPC server that ClientGRPC talks to.
@@ -43,5 +43,5 @@ func (m *ServerGRPC) Exec(ctx context.Context, req *proto.Request) (*proto.Respo
 		return nil, err
 	}
 	v, err := m.Impl.Exec(req.Name, args...)
-	return &proto.Response{Response: v.Bytes}, err
+	return &proto.Response{Response: v.Bytes, Type: v.Type}, err
 }

grpc/intefaces.go

@@ -2,60 +2,43 @@ package grpc
 
 import (
 	"context"
-	"encoding/json"
 
 	"github.com/hashicorp/go-plugin"
 	"github.com/yaoapp/kun/grpc/proto"
-	"github.com/yaoapp/kun/maps"
 	"google.golang.org/grpc"
 )
 
-// Handshake is a common handshake that is shared by plugin and host.
-var Handshake = plugin.HandshakeConfig{
-	// This isn't required when using VersionedPlugins
-	ProtocolVersion:  1,
-	MagicCookieKey:   "MODEL_PLUGIN",
-	MagicCookieValue: "hello",
-}
+// Level represents a log level.
+type Level int32
 
-// PluginMap is the map of plugins we can dispense.
-var PluginMap = map[string]plugin.Plugin{
-	"model": &ModelGRPCPlugin{},
-}
+const (
+	// NoLevel is a special level used to indicate that no level has been
+	// set and allow for a default to be used.
+	NoLevel Level = 0
 
-// Model is the interface that we're exposing as a plugin.
-type Model interface {
-	Exec(name string, args ...interface{}) (*Response, error)
-}
+	// Trace is the most verbose level. Intended to be used for the tracing
+	// of actions in code, such as function enters/exits, etc.
+	Trace Level = 1
 
-// Response GRPC Response
-type Response struct {
-	Bytes []byte
-}
+	// Debug information for programmer lowlevel analysis.
+	Debug Level = 2
 
-// Bind bind struct
-func (res Response) Bind(v interface{}) error {
-	return json.Unmarshal(res.Bytes, &v)
-}
+	// Info information about steady state operations.
+	Info Level = 3
 
-// Map cast to map
-func (res Response) Map() (maps.MapStrAny, error) {
-	v := maps.MakeMapStrAny()
-	err := json.Unmarshal(res.Bytes, &v)
-	if err != nil {
-		return nil, err
-	}
-	return v, nil
-}
+	// Warn information about rare but handled events.
+	Warn Level = 4
 
-// MustMap cast to map
-func (res Response) MustMap() maps.MapStrAny {
-	v := maps.MakeMapStrAny()
-	err := json.Unmarshal(res.Bytes, &v)
-	if err != nil {
-		panic(err)
-	}
-	return v
+	// Error information about unrecoverable events.
+	Error Level = 5
+
+	// Off disables all logging output.
+	Off Level = 6
+)
+
+// Model is the interface that we're exposing as a plugin.
+type Model interface {
+	Exec(name string, args ...interface{}) (*Response, error)
 }
 
 // ModelGRPCPlugin This is the implementation of plugin.Plugin so we can serve/consume this.
@@ -67,6 +50,25 @@ type ModelGRPCPlugin struct {
 	Impl Model
 }
 
+// Handshake is a common handshake that is shared by plugin and host.
+var Handshake = plugin.HandshakeConfig{
+	// This isn't required when using VersionedPlugins
+	ProtocolVersion:  1,
+	MagicCookieKey:   "GOU_MODEL_PLUGIN",
+	MagicCookieValue: "GOU VER0.6.0",
+}
+
+// PluginMap is the map of plugins we can dispense.
+var PluginMap = map[string]plugin.Plugin{
+	"model": &ModelGRPCPlugin{},
+}
+
+// Response GRPC Response
+type Response struct {
+	Bytes []byte
+	Type  string
+}
+
 // GRPCServer the GRPC Server
 func (p *ModelGRPCPlugin) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error {
 	proto.RegisterModelServer(s, &ServerGRPC{Impl: p.Impl})

grpc/proto/model.pb.go

@@ -10,6 +10,7 @@ message Request {
 
 message Response {
     bytes response = 1;
+    string type = 2;
 }
 
 service Model {

grpc/proto/model.proto

@@ -0,0 +1,103 @@
+package grpc
+
+import (
+	jsoniter "github.com/json-iterator/go"
+	"github.com/yaoapp/kun/any"
+	"github.com/yaoapp/kun/maps"
+)
+
+// Bind bind struct
+func (res Response) Bind(v interface{}) error {
+	return jsoniter.Unmarshal(res.Bytes, &v)
+}
+
+// MustBind bind struct
+func (res Response) MustBind(v interface{}) {
+	err := res.Bind(&v)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Interface bind struct
+func (res Response) Interface() (interface{}, error) {
+	var v interface{}
+	err := jsoniter.Unmarshal(res.Bytes, &v)
+	return v, err
+}
+
+// MustInterface bind struct
+func (res Response) MustInterface() interface{} {
+	v, err := res.Interface()
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Map cast to map
+func (res Response) Map() (maps.MapStrAny, error) {
+	v := maps.Map{}
+	err := jsoniter.Unmarshal(res.Bytes, &v)
+	if err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// MustMap cast to map
+func (res Response) MustMap() maps.MapStrAny {
+	v, err := res.Map()
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Array cast to array | slice
+func (res Response) Array() ([]interface{}, error) {
+	v := []interface{}{}
+	err := jsoniter.Unmarshal(res.Bytes, &v)
+	if err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// MustArray cast to array | slice
+func (res Response) MustArray() []interface{} {
+	v, err := res.Array()
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Value get the response value
+func (res Response) Value() (interface{}, error) {
+	switch res.Type {
+	case "interface":
+		return res.Interface()
+	case "string":
+		return string(res.Bytes), nil
+	case "integer", "int":
+		return any.Of(string(res.Bytes)).CInt(), nil
+	case "float", "double":
+		return any.Of(string(res.Bytes)).CFloat(), nil
+	case "map":
+		return res.Map()
+	case "array", "slice":
+		return res.Array()
+	default:
+		return res.Bytes, nil
+	}
+}
+
+// MustValue get the response value
+func (res Response) MustValue() interface{} {
+	v, err := res.Value()
+	if err != nil {
+		panic(err)
+	}
+	return v
+}

grpc/response.go

@@ -0,0 +1,36 @@
+package grpc
+
+import (
+	"io"
+
+	"github.com/hashicorp/go-hclog"
+	"github.com/hashicorp/go-plugin"
+)
+
+// Plugin Here is a real implementation of Pluine that writes to a local file with
+// the key name and the contents are the value of the key.
+type Plugin struct {
+	Logger hclog.Logger
+}
+
+// SetLogger set logger output
+func (plugin *Plugin) SetLogger(output io.Writer, level Level) {
+	logger := hclog.New(&hclog.LoggerOptions{
+		Level:      hclog.Level(level),
+		Output:     output,
+		JSONFormat: true,
+	})
+	plugin.Logger = logger
+}
+
+// Serve GRPC Server
+func Serve(model Model) {
+	pluginMap := map[string]plugin.Plugin{
+		"model": &ModelGRPCPlugin{Impl: model},
+	}
+	plugin.Serve(&plugin.ServeConfig{
+		HandshakeConfig: Handshake,
+		Plugins:         pluginMap,
+		GRPCServer:      plugin.DefaultGRPCServer,
+	})
+}