jhttp: extend and simplify request processing hooks (#65)

Add a new hook to the Bridge options to allow the caller to handle parsing the
HTTP request into JSON-RPC requests. Remove the old content-type check hook.

The request check hook remains, but setting either it or the new parse hook
disables the default method POST and content-type checks; the hooks are now
fully responsible for checking the structure of the request.

Without either of these hooks set, the default behaviour does not change.

jhttp/bridge.go

@@ -5,7 +5,6 @@
 package jhttp
 
 import (
- "bytes"
  "context"
  "encoding/json"
  "fmt"
@@ -19,9 +18,12 @@ import (
 
 // A Bridge is a http.Handler that bridges requests to a JSON-RPC server.
 //
-// The body of the HTTP POST request must contain the complete JSON-RPC request
-// message, encoded with Content-Type: application/json. Either a single
-// request object or a list of request objects is supported.
+// By default, the bridge accepts only HTTP POST requests with the complete
+// JSON-RPC request message in the body, with Content-Type application/json.
+// Either a single request object or a list of request objects is supported.
+//
+// If either a CheckRequest or ParseRequest hook is set, these requirements are
+// disabled, and the hooks are responsible for checking request structure.
 //
 // If the request completes, whether or not there is an error, the HTTP
 // response is 200 (OK) for ordinary requests or 204 (No Response) for
@@ -35,22 +37,27 @@ import (
 // client, allowing an EncodeContext callback to retrieve state from the HTTP
 // headers. Use jhttp.HTTPRequest to retrieve the request from the context.
 type Bridge struct {
- local  server.Local
- checkType func(string) bool
- checkReq func(*http.Request) error
+ local server.Local
+ checkReq func(*http.Request) error
+ parseReq func(*http.Request) ([]*jrpc2.Request, error)
 }
 
 // ServeHTTP implements the required method of http.Handler.
 func (b Bridge) ServeHTTP(w http.ResponseWriter, req *http.Request) {
- if req.Method != "POST" {
- w.WriteHeader(http.StatusMethodNotAllowed)
- return
- }
- if !b.checkType(req.Header.Get("Content-Type")) {
- w.WriteHeader(http.StatusUnsupportedMediaType)
- return
+ // If neither a check hook nor a parse hook are defined, insist that the
+ // method is POST and the content-type is application/json. Setting either
+ // hook disables these checks.
+ if b.checkReq == nil && b.parseReq == nil {
+ if req.Method != "POST" {
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ return
+ }
+ if req.Header.Get("Content-Type") != "application/json" {
+ w.WriteHeader(http.StatusUnsupportedMediaType)
+ return
+ }
  }
- if err := b.checkReq(req); err != nil {
+ if err := b.checkHTTPRequest(req); err != nil {
  w.WriteHeader(http.StatusInternalServerError)
  fmt.Fprintln(w, err.Error())
  return
@@ -62,19 +69,14 @@ func (b Bridge) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 }
 
 func (b Bridge) serveInternal(w http.ResponseWriter, req *http.Request) error {
- body, err := io.ReadAll(req.Body)
- if err != nil {
- return err
- }
-
  // The HTTP request requires a response, but the server will not reply if
  // all the requests are notifications. Check whether we have any calls
  // needing a response, and choose whether to wait for a reply based on that.
  //
  // Note that we are forgiving about a missing version marker in a request,
  // since we can't tell at this point whether the server is willing to accept
  // messages like that.
- jreq, err := jrpc2.ParseRequests(body)
+ jreq, err := b.parseHTTPRequest(req)
  if err != nil && err != jrpc2.ErrInvalidVersion {
  return err
  }
@@ -126,10 +128,15 @@ func (b Bridge) serveInternal(w http.ResponseWriter, req *http.Request) error {
  rsp.SetID(inboundID[i])
  }
 
- // If the original request was a single message, make sure we encode the
- // response the same way.
+ // If there is only a single reply, send it alone; otherwise encode a batch.
+ // Per the spec (https://www.jsonrpc.org/specification#batch), this is OK;
+ // we are not required to respond to a batch with an array:
+ //
+ // The Server SHOULD respond with an Array containing the corresponding
+ // Response objects
+ //
  var reply []byte
- if len(rsps) == 1 && !bytes.HasPrefix(bytes.TrimSpace(body), []byte("[")) {
+ if len(rsps) == 1 {
  reply, err = json.Marshal(rsps[0])
  } else {
  reply, err = json.Marshal(rsps)
@@ -143,6 +150,24 @@ func (b Bridge) serveInternal(w http.ResponseWriter, req *http.Request) error {
  return nil
 }
 
+func (b Bridge) checkHTTPRequest(req *http.Request) error {
+ if b.checkReq != nil {
+ return b.checkReq(req)
+ }
+ return nil
+}
+
+func (b Bridge) parseHTTPRequest(req *http.Request) ([]*jrpc2.Request, error) {
+ if b.parseReq != nil {
+ return b.parseReq(req)
+ }
+ body, err := io.ReadAll(req.Body)
+ if err != nil {
+ return nil, err
+ }
+ return jrpc2.ParseRequests(body)
+}
+
 // Close closes the channel to the server, waits for the server to exit, and
 // reports its exit status.
 func (b Bridge) Close() error { return b.local.Close() }
@@ -162,8 +187,8 @@ func NewBridge(mux jrpc2.Assigner, opts *BridgeOptions) Bridge {
  Client: opts.clientOptions(),
  Server: opts.serverOptions(),
  }),
- checkType: opts.checkContentType(),
- checkReq: opts.checkRequest(),
+ checkReq: opts.checkRequest(),
+ parseReq: opts.parseRequest(),
  }
 }
 
@@ -176,15 +201,20 @@ type BridgeOptions struct {
  // Options for the bridge server (default nil).
  Server *jrpc2.ServerOptions
 
- // If non-nil, this function is called to check whether the HTTP request's
- // declared content-type is valid. If this function returns false, the
- // request is rejected. If nil, the default check requires a content type of
- // "application/json".
- CheckContentType func(contentType string) bool
-
  // If non-nil, this function is called to check the HTTP request. If this
  // function reports an error, the request is rejected.
+ //
+ // Setting this hook disables the default requirement that the request
+ // method be POST and the content-type be application/json.
  CheckRequest func(*http.Request) error
+
+ // If non-nil, this function is called to parse JSON-RPC requests from the
+ // HTTP request. If this function reports an error, the request fails. By
+ // default, the bridge uses jrpc2.ParseRequests on the HTTP request body.
+ //
+ // Setting this hook disables the default requirement that the request
+ // method be POST and the content-type be application/json.
+ ParseRequest func(*http.Request) ([]*jrpc2.Request, error)
 }
 
 func (o *BridgeOptions) clientOptions() *jrpc2.ClientOptions {
@@ -201,18 +231,18 @@ func (o *BridgeOptions) serverOptions() *jrpc2.ServerOptions {
  return o.Server
 }
 
-func (o *BridgeOptions) checkContentType() func(string) bool {
- if o == nil || o.CheckContentType == nil {
- return func(ctype string) bool { return ctype == "application/json" }
+func (o *BridgeOptions) checkRequest() func(*http.Request) error {
+ if o == nil {
+ return nil
  }
- return o.CheckContentType
+ return o.CheckRequest
 }
 
-func (o *BridgeOptions) checkRequest() func(*http.Request) error {
- if o == nil || o.CheckRequest == nil {
- return func(*http.Request) error { return nil }
+func (o *BridgeOptions) parseRequest() func(*http.Request) ([]*jrpc2.Request, error) {
+ if o == nil {
+ return nil
  }
- return o.CheckRequest
+ return o.ParseRequest
 }
 
 type httpReqKey struct{}