Initial QSfera import

Server/vendor/go-micro.dev/v4/codec/jsonrpc/client.go

@@ -0,0 +1,99 @@
+package jsonrpc
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"sync"
+
+	"go-micro.dev/v4/codec"
+)
+
+type clientCodec struct {
+
+	// temporary work space
+	req  clientRequest
+	resp clientResponse
+
+	c io.Closer
+
+	dec     *json.Decoder // for reading JSON values
+	enc     *json.Encoder // for writing JSON values
+	pending map[interface{}]string
+
+	sync.Mutex
+}
+
+type clientRequest struct {
+	Params [1]interface{} `json:"params"`
+	ID     interface{}    `json:"id"`
+	Method string         `json:"method"`
+}
+
+type clientResponse struct {
+	ID     interface{}      `json:"id"`
+	Result *json.RawMessage `json:"result"`
+	Error  interface{}      `json:"error"`
+}
+
+func newClientCodec(conn io.ReadWriteCloser) *clientCodec {
+	return &clientCodec{
+		dec:     json.NewDecoder(conn),
+		enc:     json.NewEncoder(conn),
+		c:       conn,
+		pending: make(map[interface{}]string),
+	}
+}
+
+func (c *clientCodec) Write(m *codec.Message, b interface{}) error {
+	c.Lock()
+	c.pending[m.Id] = m.Method
+	c.Unlock()
+	c.req.Method = m.Method
+	c.req.Params[0] = b
+	c.req.ID = m.Id
+	return c.enc.Encode(&c.req)
+}
+
+func (r *clientResponse) reset() {
+	r.ID = 0
+	r.Result = nil
+	r.Error = nil
+}
+
+func (c *clientCodec) ReadHeader(m *codec.Message) error {
+	c.resp.reset()
+	if err := c.dec.Decode(&c.resp); err != nil {
+		return err
+	}
+
+	c.Lock()
+	m.Method = c.pending[c.resp.ID]
+	delete(c.pending, c.resp.ID)
+	c.Unlock()
+
+	m.Error = ""
+	m.Id = fmt.Sprintf("%v", c.resp.ID)
+	if c.resp.Error != nil {
+		x, ok := c.resp.Error.(string)
+		if !ok {
+			return fmt.Errorf("invalid error %v", c.resp.Error)
+		}
+		if x == "" {
+			x = "unspecified error"
+		}
+		m.Error = x
+	}
+	return nil
+}
+
+func (c *clientCodec) ReadBody(x interface{}) error {
+	if x == nil || c.resp.Result == nil {
+		return nil
+	}
+	return json.Unmarshal(*c.resp.Result, x)
+}
+
+func (c *clientCodec) Close() error {
+	return c.c.Close()
+}

Server/vendor/go-micro.dev/v4/codec/jsonrpc/jsonrpc.go

@@ -0,0 +1,88 @@
+// Package jsonrpc provides a json-rpc 1.0 codec
+package jsonrpc
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"go-micro.dev/v4/codec"
+)
+
+type jsonCodec struct {
+	rwc io.ReadWriteCloser
+	buf *bytes.Buffer
+	c   *clientCodec
+	s   *serverCodec
+	mt  codec.MessageType
+}
+
+func (j *jsonCodec) Close() error {
+	j.buf.Reset()
+	return j.rwc.Close()
+}
+
+func (j *jsonCodec) String() string {
+	return "json-rpc"
+}
+
+func (j *jsonCodec) Write(m *codec.Message, b interface{}) error {
+	switch m.Type {
+	case codec.Request:
+		return j.c.Write(m, b)
+	case codec.Response, codec.Error:
+		return j.s.Write(m, b)
+	case codec.Event:
+		data, err := json.Marshal(b)
+		if err != nil {
+			return err
+		}
+		_, err = j.rwc.Write(data)
+		return err
+	default:
+		return fmt.Errorf("Unrecognized message type: %v", m.Type)
+	}
+}
+
+func (j *jsonCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
+	j.buf.Reset()
+	j.mt = mt
+
+	switch mt {
+	case codec.Request:
+		return j.s.ReadHeader(m)
+	case codec.Response:
+		return j.c.ReadHeader(m)
+	case codec.Event:
+		_, err := io.Copy(j.buf, j.rwc)
+		return err
+	default:
+		return fmt.Errorf("Unrecognized message type: %v", mt)
+	}
+}
+
+func (j *jsonCodec) ReadBody(b interface{}) error {
+	switch j.mt {
+	case codec.Request:
+		return j.s.ReadBody(b)
+	case codec.Response:
+		return j.c.ReadBody(b)
+	case codec.Event:
+		if b != nil {
+			return json.Unmarshal(j.buf.Bytes(), b)
+		}
+	default:
+		return fmt.Errorf("Unrecognized message type: %v", j.mt)
+	}
+	return nil
+}
+
+func NewCodec(rwc io.ReadWriteCloser) codec.Codec {
+	return &jsonCodec{
+		buf: bytes.NewBuffer(nil),
+		rwc: rwc,
+		c:   newClientCodec(rwc),
+		s:   newServerCodec(rwc),
+	}
+}

Server/vendor/go-micro.dev/v4/codec/jsonrpc/server.go

@@ -0,0 +1,87 @@
+package jsonrpc
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"go-micro.dev/v4/codec"
+)
+
+type serverCodec struct {
+	dec *json.Decoder // for reading JSON values
+	enc *json.Encoder // for writing JSON values
+	c   io.Closer
+
+	// temporary work space
+	req  serverRequest
+	resp serverResponse
+}
+
+type serverRequest struct {
+	ID     interface{}      `json:"id"`
+	Params *json.RawMessage `json:"params"`
+	Method string           `json:"method"`
+}
+
+type serverResponse struct {
+	ID     interface{} `json:"id"`
+	Result interface{} `json:"result"`
+	Error  interface{} `json:"error"`
+}
+
+func newServerCodec(conn io.ReadWriteCloser) *serverCodec {
+	return &serverCodec{
+		dec: json.NewDecoder(conn),
+		enc: json.NewEncoder(conn),
+		c:   conn,
+	}
+}
+
+func (r *serverRequest) reset() {
+	r.Method = ""
+	if r.Params != nil {
+		*r.Params = (*r.Params)[0:0]
+	}
+	if r.ID != nil {
+		r.ID = nil
+	}
+}
+
+func (c *serverCodec) ReadHeader(m *codec.Message) error {
+	c.req.reset()
+	if err := c.dec.Decode(&c.req); err != nil {
+		return err
+	}
+	m.Method = c.req.Method
+	m.Id = fmt.Sprintf("%v", c.req.ID)
+	c.req.ID = nil
+	return nil
+}
+
+func (c *serverCodec) ReadBody(x interface{}) error {
+	if x == nil {
+		return nil
+	}
+	var params [1]interface{}
+	params[0] = x
+	return json.Unmarshal(*c.req.Params, &params)
+}
+
+var null = json.RawMessage([]byte("null"))
+
+func (c *serverCodec) Write(m *codec.Message, x interface{}) error {
+	var resp serverResponse
+	resp.ID = m.Id
+	resp.Result = x
+	if m.Error == "" {
+		resp.Error = nil
+	} else {
+		resp.Error = m.Error
+	}
+	return c.enc.Encode(resp)
+}
+
+func (c *serverCodec) Close() error {
+	return c.c.Close()
+}