--- /dev/null
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package jsonrpc2
+
+import (
+ "encoding/json"
+ "fmt"
+
+ errors "golang.org/x/xerrors"
+)
+
+// Message is the interface to all jsonrpc2 message types.
+// They share no common functionality, but are a closed set of concrete types
+// that are allowed to implement this interface. The message types are *Call,
+// *Notification and *Response.
+type Message interface {
+ // isJSONRPC2Message is used to make the set of message implementations a
+ // closed set.
+ isJSONRPC2Message()
+}
+
+// Request is the shared interface to jsonrpc2 messages that request
+// a method be invoked.
+// The request types are a closed set of *Call and *Notification.
+type Request interface {
+ Message
+ // Method is a string containing the method name to invoke.
+ Method() string
+ // Params is either a struct or an array with the parameters of the method.
+ Params() json.RawMessage
+ // isJSONRPC2Request is used to make the set of request implementations closed.
+ isJSONRPC2Request()
+}
+
+// Notification is a request for which a response cannot occur, and as such
+// it has not ID.
+type Notification struct {
+ // Method is a string containing the method name to invoke.
+ method string
+ params json.RawMessage
+}
+
+// Call is a request that expects a response.
+// The response will have a matching ID.
+type Call struct {
+ // Method is a string containing the method name to invoke.
+ method string
+ // Params is either a struct or an array with the parameters of the method.
+ params json.RawMessage
+ // id of this request, used to tie the Response back to the request.
+ id ID
+}
+
+// Response is a reply to a Call.
+// It will have the same ID as the call it is a response to.
+type Response struct {
+ // result is the content of the response.
+ result json.RawMessage
+ // err is set only if the call failed.
+ err error
+ // ID of the request this is a response to.
+ id ID
+}
+
+// NewNotification constructs a new Notification message for the supplied
+// method and parameters.
+func NewNotification(method string, params interface{}) (*Notification, error) {
+ p, merr := marshalToRaw(params)
+ return &Notification{method: method, params: p}, merr
+}
+
+func (msg *Notification) Method() string { return msg.method }
+func (msg *Notification) Params() json.RawMessage { return msg.params }
+func (msg *Notification) isJSONRPC2Message() {}
+func (msg *Notification) isJSONRPC2Request() {}
+
+func (n *Notification) MarshalJSON() ([]byte, error) {
+ msg := wireRequest{Method: n.method, Params: &n.params}
+ data, err := json.Marshal(msg)
+ if err != nil {
+ return data, fmt.Errorf("marshaling notification: %w", err)
+ }
+ return data, nil
+}
+
+func (n *Notification) UnmarshalJSON(data []byte) error {
+ msg := wireRequest{}
+ if err := json.Unmarshal(data, &msg); err != nil {
+ return fmt.Errorf("unmarshaling notification: %w", err)
+ }
+ n.method = msg.Method
+ if msg.Params != nil {
+ n.params = *msg.Params
+ }
+ return nil
+}
+
+// NewCall constructs a new Call message for the supplied ID, method and
+// parameters.
+func NewCall(id ID, method string, params interface{}) (*Call, error) {
+ p, merr := marshalToRaw(params)
+ return &Call{id: id, method: method, params: p}, merr
+}
+
+func (msg *Call) Method() string { return msg.method }
+func (msg *Call) Params() json.RawMessage { return msg.params }
+func (msg *Call) ID() ID { return msg.id }
+func (msg *Call) isJSONRPC2Message() {}
+func (msg *Call) isJSONRPC2Request() {}
+
+func (c *Call) MarshalJSON() ([]byte, error) {
+ msg := wireRequest{Method: c.method, Params: &c.params, ID: &c.id}
+ data, err := json.Marshal(msg)
+ if err != nil {
+ return data, fmt.Errorf("marshaling call: %w", err)
+ }
+ return data, nil
+}
+
+func (c *Call) UnmarshalJSON(data []byte) error {
+ msg := wireRequest{}
+ if err := json.Unmarshal(data, &msg); err != nil {
+ return fmt.Errorf("unmarshaling call: %w", err)
+ }
+ c.method = msg.Method
+ if msg.Params != nil {
+ c.params = *msg.Params
+ }
+ if msg.ID != nil {
+ c.id = *msg.ID
+ }
+ return nil
+}
+
+// NewResponse constructs a new Response message that is a reply to the
+// supplied. If err is set result may be ignored.
+func NewResponse(id ID, result interface{}, err error) (*Response, error) {
+ r, merr := marshalToRaw(result)
+ return &Response{id: id, result: r, err: err}, merr
+}
+
+func (msg *Response) ID() ID { return msg.id }
+func (msg *Response) Result() json.RawMessage { return msg.result }
+func (msg *Response) Err() error { return msg.err }
+func (msg *Response) isJSONRPC2Message() {}
+
+func (r *Response) MarshalJSON() ([]byte, error) {
+ msg := &wireResponse{Error: toWireError(r.err), ID: &r.id}
+ if msg.Error == nil {
+ msg.Result = &r.result
+ }
+ data, err := json.Marshal(msg)
+ if err != nil {
+ return data, fmt.Errorf("marshaling notification: %w", err)
+ }
+ return data, nil
+}
+
+func toWireError(err error) *wireError {
+ if err == nil {
+ // no error, the response is complete
+ return nil
+ }
+ if err, ok := err.(*wireError); ok {
+ // already a wire error, just use it
+ return err
+ }
+ result := &wireError{Message: err.Error()}
+ var wrapped *wireError
+ if errors.As(err, &wrapped) {
+ // if we wrapped a wire error, keep the code from the wrapped error
+ // but the message from the outer error
+ result.Code = wrapped.Code
+ }
+ return result
+}
+
+func (r *Response) UnmarshalJSON(data []byte) error {
+ msg := wireResponse{}
+ if err := json.Unmarshal(data, &msg); err != nil {
+ return fmt.Errorf("unmarshaling jsonrpc response: %w", err)
+ }
+ if msg.Result != nil {
+ r.result = *msg.Result
+ }
+ if msg.Error != nil {
+ r.err = msg.Error
+ }
+ if msg.ID != nil {
+ r.id = *msg.ID
+ }
+ return nil
+}
+
+func DecodeMessage(data []byte) (Message, error) {
+ msg := wireCombined{}
+ if err := json.Unmarshal(data, &msg); err != nil {
+ return nil, fmt.Errorf("unmarshaling jsonrpc message: %w", err)
+ }
+ if msg.Method == "" {
+ // no method, should be a response
+ if msg.ID == nil {
+ return nil, ErrInvalidRequest
+ }
+ response := &Response{id: *msg.ID}
+ if msg.Error != nil {
+ response.err = msg.Error
+ }
+ if msg.Result != nil {
+ response.result = *msg.Result
+ }
+ return response, nil
+ }
+ // has a method, must be a request
+ if msg.ID == nil {
+ // request with no ID is a notify
+ notify := &Notification{method: msg.Method}
+ if msg.Params != nil {
+ notify.params = *msg.Params
+ }
+ return notify, nil
+ }
+ // request with an ID, must be a call
+ call := &Call{method: msg.Method, id: *msg.ID}
+ if msg.Params != nil {
+ call.params = *msg.Params
+ }
+ return call, nil
+}
+
+func marshalToRaw(obj interface{}) (json.RawMessage, error) {
+ data, err := json.Marshal(obj)
+ if err != nil {
+ return json.RawMessage{}, err
+ }
+ return json.RawMessage(data), nil
+}
projects / dotfiles / .git / blobdiff