mirror of
https://github.com/fluencelabs/tendermint
synced 2025-04-25 06:42:16 +00:00
90465f727f
Continues from #3280 in building support for batched requests/responses in the JSON RPC (as per issue #3213). * Add JSON RPC batching for client and server As per #3213, this adds support for [JSON RPC batch requests and responses](https://www.jsonrpc.org/specification#batch). * Add additional checks to ensure client responses are the same as results * Fix case where a notification is sent and no response is expected * Add test to check that JSON RPC notifications in a batch are left out in responses * Update CHANGELOG_PENDING.md * Update PR number now that PR has been created * Make errors start with lowercase letter * Refactor batch functionality to be standalone This refactors the batching functionality to rather act in a standalone way. In light of supporting concurrent goroutines making use of the same client, it would make sense to have batching functionality where one could create a batch of requests per goroutine and send that batch without interfering with a batch from another goroutine. * Add examples for simple and batch HTTP client usage * Check errors from writer and remove nolinter directives * Make error strings start with lowercase letter * Refactor examples to make them testable * Use safer deferred shutdown for example Tendermint test node * Recompose rpcClient interface from pre-existing interface components * Rename WaitGroup for brevity * Replace empty ID string with request ID * Remove extraneous test case * Convert first letter of errors.Wrap() messages to lowercase * Remove extraneous function parameter * Make variable declaration terse * Reorder WaitGroup.Done call to help prevent race conditions in the face of failure * Swap mutex to value representation and remove initialization * Restore empty JSONRPC string ID in response to prevent nil * Make JSONRPCBufferedRequest private * Revert PR hard link in CHANGELOG_PENDING * Add client ID for JSONRPCClient This adds code to automatically generate a randomized client ID for the JSONRPCClient, and adds a check of the IDs in the responses (if one was set in the requests). * Extract response ID validation into separate function * Remove extraneous comments * Reorder fields to indicate clearly which are protected by the mutex * Refactor for loop to remove indexing * Restructure and combine loop * Flatten conditional block for better readability * Make multi-variable declaration slightly more readable * Change for loop style * Compress error check statements * Make function description more generic to show that we support different protocols * Preallocate memory for request and result objects
92 lines
2.2 KiB
Go
92 lines
2.2 KiB
Go
package rpcserver
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"net/http"
|
|
"regexp"
|
|
"strconv"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var (
|
|
// Parts of regular expressions
|
|
atom = "[A-Z0-9!#$%&'*+\\-/=?^_`{|}~]+"
|
|
dotAtom = atom + `(?:\.` + atom + `)*`
|
|
domain = `[A-Z0-9.-]+\.[A-Z]{2,4}`
|
|
|
|
RE_INT = regexp.MustCompile(`^-?[0-9]+$`)
|
|
RE_HEX = regexp.MustCompile(`^(?i)[a-f0-9]+$`)
|
|
RE_EMAIL = regexp.MustCompile(`^(?i)(` + dotAtom + `)@(` + dotAtom + `)$`)
|
|
RE_ADDRESS = regexp.MustCompile(`^(?i)[a-z0-9]{25,34}$`)
|
|
RE_HOST = regexp.MustCompile(`^(?i)(` + domain + `)$`)
|
|
|
|
//RE_ID12 = regexp.MustCompile(`^[a-zA-Z0-9]{12}$`)
|
|
)
|
|
|
|
func GetParam(r *http.Request, param string) string {
|
|
s := r.URL.Query().Get(param)
|
|
if s == "" {
|
|
s = r.FormValue(param)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func GetParamByteSlice(r *http.Request, param string) ([]byte, error) {
|
|
s := GetParam(r, param)
|
|
return hex.DecodeString(s)
|
|
}
|
|
|
|
func GetParamInt64(r *http.Request, param string) (int64, error) {
|
|
s := GetParam(r, param)
|
|
i, err := strconv.ParseInt(s, 10, 64)
|
|
if err != nil {
|
|
return 0, errors.Errorf(param, err.Error())
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func GetParamInt32(r *http.Request, param string) (int32, error) {
|
|
s := GetParam(r, param)
|
|
i, err := strconv.ParseInt(s, 10, 32)
|
|
if err != nil {
|
|
return 0, errors.Errorf(param, err.Error())
|
|
}
|
|
return int32(i), nil
|
|
}
|
|
|
|
func GetParamUint64(r *http.Request, param string) (uint64, error) {
|
|
s := GetParam(r, param)
|
|
i, err := strconv.ParseUint(s, 10, 64)
|
|
if err != nil {
|
|
return 0, errors.Errorf(param, err.Error())
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func GetParamUint(r *http.Request, param string) (uint, error) {
|
|
s := GetParam(r, param)
|
|
i, err := strconv.ParseUint(s, 10, 64)
|
|
if err != nil {
|
|
return 0, errors.Errorf(param, err.Error())
|
|
}
|
|
return uint(i), nil
|
|
}
|
|
|
|
func GetParamRegexp(r *http.Request, param string, re *regexp.Regexp) (string, error) {
|
|
s := GetParam(r, param)
|
|
if !re.MatchString(s) {
|
|
return "", errors.Errorf(param, "did not match regular expression %v", re.String())
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func GetParamFloat64(r *http.Request, param string) (float64, error) {
|
|
s := GetParam(r, param)
|
|
f, err := strconv.ParseFloat(s, 64)
|
|
if err != nil {
|
|
return 0, errors.Errorf(param, err.Error())
|
|
}
|
|
return f, nil
|
|
}
|