diff --git a/internal/inspect/rpc/rpc.go b/internal/inspect/rpc/rpc.go index 7ed47962a..5c0d1a7e9 100644 --- a/internal/inspect/rpc/rpc.go +++ b/internal/inspect/rpc/rpc.go @@ -41,16 +41,16 @@ func Routes(cfg config.RPCConfig, s state.Store, bs state.BlockStore, es []index Logger: logger, } return core.RoutesMap{ - "blockchain": server.NewRPCFunc(env.BlockchainInfo, "minHeight,maxHeight", true), - "consensus_params": server.NewRPCFunc(env.ConsensusParams, "height", true), - "block": server.NewRPCFunc(env.Block, "height", true), - "block_by_hash": server.NewRPCFunc(env.BlockByHash, "hash", true), - "block_results": server.NewRPCFunc(env.BlockResults, "height", true), - "commit": server.NewRPCFunc(env.Commit, "height", true), - "validators": server.NewRPCFunc(env.Validators, "height,page,per_page", true), - "tx": server.NewRPCFunc(env.Tx, "hash,prove", true), - "tx_search": server.NewRPCFunc(env.TxSearch, "query,prove,page,per_page,order_by", false), - "block_search": server.NewRPCFunc(env.BlockSearch, "query,page,per_page,order_by", false), + "blockchain": server.NewRPCFunc(env.BlockchainInfo, "minHeight,maxHeight"), + "consensus_params": server.NewRPCFunc(env.ConsensusParams, "height"), + "block": server.NewRPCFunc(env.Block, "height"), + "block_by_hash": server.NewRPCFunc(env.BlockByHash, "hash"), + "block_results": server.NewRPCFunc(env.BlockResults, "height"), + "commit": server.NewRPCFunc(env.Commit, "height"), + "validators": server.NewRPCFunc(env.Validators, "height,page,per_page"), + "tx": server.NewRPCFunc(env.Tx, "hash,prove"), + "tx_search": server.NewRPCFunc(env.TxSearch, "query,prove,page,per_page,order_by"), + "block_search": server.NewRPCFunc(env.BlockSearch, "query,page,per_page,order_by"), } } diff --git a/internal/rpc/core/routes.go b/internal/rpc/core/routes.go index dd53711c3..2231ae1e5 100644 --- a/internal/rpc/core/routes.go +++ b/internal/rpc/core/routes.go @@ -17,46 +17,46 @@ func (env *Environment) GetRoutes() RoutesMap { "unsubscribe_all": rpc.NewWSRPCFunc(env.UnsubscribeAll, ""), // info API - "health": rpc.NewRPCFunc(env.Health, "", false), - "status": rpc.NewRPCFunc(env.Status, "", false), - "net_info": rpc.NewRPCFunc(env.NetInfo, "", false), - "blockchain": rpc.NewRPCFunc(env.BlockchainInfo, "minHeight,maxHeight", true), - "genesis": rpc.NewRPCFunc(env.Genesis, "", true), - "genesis_chunked": rpc.NewRPCFunc(env.GenesisChunked, "chunk", true), - "header": rpc.NewRPCFunc(env.Header, "height", true), - "header_by_hash": rpc.NewRPCFunc(env.HeaderByHash, "hash", true), - "block": rpc.NewRPCFunc(env.Block, "height", true), - "block_by_hash": rpc.NewRPCFunc(env.BlockByHash, "hash", true), - "block_results": rpc.NewRPCFunc(env.BlockResults, "height", true), - "commit": rpc.NewRPCFunc(env.Commit, "height", true), - "check_tx": rpc.NewRPCFunc(env.CheckTx, "tx", true), - "remove_tx": rpc.NewRPCFunc(env.RemoveTx, "txkey", false), - "tx": rpc.NewRPCFunc(env.Tx, "hash,prove", true), - "tx_search": rpc.NewRPCFunc(env.TxSearch, "query,prove,page,per_page,order_by", false), - "block_search": rpc.NewRPCFunc(env.BlockSearch, "query,page,per_page,order_by", false), - "validators": rpc.NewRPCFunc(env.Validators, "height,page,per_page", true), - "dump_consensus_state": rpc.NewRPCFunc(env.DumpConsensusState, "", false), - "consensus_state": rpc.NewRPCFunc(env.GetConsensusState, "", false), - "consensus_params": rpc.NewRPCFunc(env.ConsensusParams, "height", true), - "unconfirmed_txs": rpc.NewRPCFunc(env.UnconfirmedTxs, "limit", false), - "num_unconfirmed_txs": rpc.NewRPCFunc(env.NumUnconfirmedTxs, "", false), + "health": rpc.NewRPCFunc(env.Health, ""), + "status": rpc.NewRPCFunc(env.Status, ""), + "net_info": rpc.NewRPCFunc(env.NetInfo, ""), + "blockchain": rpc.NewRPCFunc(env.BlockchainInfo, "minHeight,maxHeight"), + "genesis": rpc.NewRPCFunc(env.Genesis, ""), + "genesis_chunked": rpc.NewRPCFunc(env.GenesisChunked, "chunk"), + "header": rpc.NewRPCFunc(env.Header, "height"), + "header_by_hash": rpc.NewRPCFunc(env.HeaderByHash, "hash"), + "block": rpc.NewRPCFunc(env.Block, "height"), + "block_by_hash": rpc.NewRPCFunc(env.BlockByHash, "hash"), + "block_results": rpc.NewRPCFunc(env.BlockResults, "height"), + "commit": rpc.NewRPCFunc(env.Commit, "height"), + "check_tx": rpc.NewRPCFunc(env.CheckTx, "tx"), + "remove_tx": rpc.NewRPCFunc(env.RemoveTx, "txkey"), + "tx": rpc.NewRPCFunc(env.Tx, "hash,prove"), + "tx_search": rpc.NewRPCFunc(env.TxSearch, "query,prove,page,per_page,order_by"), + "block_search": rpc.NewRPCFunc(env.BlockSearch, "query,page,per_page,order_by"), + "validators": rpc.NewRPCFunc(env.Validators, "height,page,per_page"), + "dump_consensus_state": rpc.NewRPCFunc(env.DumpConsensusState, ""), + "consensus_state": rpc.NewRPCFunc(env.GetConsensusState, ""), + "consensus_params": rpc.NewRPCFunc(env.ConsensusParams, "height"), + "unconfirmed_txs": rpc.NewRPCFunc(env.UnconfirmedTxs, "limit"), + "num_unconfirmed_txs": rpc.NewRPCFunc(env.NumUnconfirmedTxs, ""), // tx broadcast API - "broadcast_tx_commit": rpc.NewRPCFunc(env.BroadcastTxCommit, "tx", false), - "broadcast_tx_sync": rpc.NewRPCFunc(env.BroadcastTxSync, "tx", false), - "broadcast_tx_async": rpc.NewRPCFunc(env.BroadcastTxAsync, "tx", false), + "broadcast_tx_commit": rpc.NewRPCFunc(env.BroadcastTxCommit, "tx"), + "broadcast_tx_sync": rpc.NewRPCFunc(env.BroadcastTxSync, "tx"), + "broadcast_tx_async": rpc.NewRPCFunc(env.BroadcastTxAsync, "tx"), // abci API - "abci_query": rpc.NewRPCFunc(env.ABCIQuery, "path,data,height,prove", false), - "abci_info": rpc.NewRPCFunc(env.ABCIInfo, "", true), + "abci_query": rpc.NewRPCFunc(env.ABCIQuery, "path,data,height,prove"), + "abci_info": rpc.NewRPCFunc(env.ABCIInfo, ""), // evidence API - "broadcast_evidence": rpc.NewRPCFunc(env.BroadcastEvidence, "evidence", false), + "broadcast_evidence": rpc.NewRPCFunc(env.BroadcastEvidence, "evidence"), } } // AddUnsafeRoutes adds unsafe routes. func (env *Environment) AddUnsafe(routes RoutesMap) { // control API - routes["unsafe_flush_mempool"] = rpc.NewRPCFunc(env.UnsafeFlushMempool, "", false) + routes["unsafe_flush_mempool"] = rpc.NewRPCFunc(env.UnsafeFlushMempool, "") } diff --git a/light/proxy/routes.go b/light/proxy/routes.go index 4fb815b7e..6f5b3c1db 100644 --- a/light/proxy/routes.go +++ b/light/proxy/routes.go @@ -19,39 +19,39 @@ func RPCRoutes(c *lrpc.Client) map[string]*rpcserver.RPCFunc { "unsubscribe_all": rpcserver.NewWSRPCFunc(c.UnsubscribeAllWS, ""), // info API - "health": rpcserver.NewRPCFunc(makeHealthFunc(c), "", false), - "status": rpcserver.NewRPCFunc(makeStatusFunc(c), "", false), - "net_info": rpcserver.NewRPCFunc(makeNetInfoFunc(c), "", false), - "blockchain": rpcserver.NewRPCFunc(makeBlockchainInfoFunc(c), "minHeight,maxHeight", true), - "genesis": rpcserver.NewRPCFunc(makeGenesisFunc(c), "", true), - "genesis_chunked": rpcserver.NewRPCFunc(makeGenesisChunkedFunc(c), "", true), - "header": rpcserver.NewRPCFunc(makeHeaderFunc(c), "height", true), - "header_by_hash": rpcserver.NewRPCFunc(makeHeaderByHashFunc(c), "hash", true), - "block": rpcserver.NewRPCFunc(makeBlockFunc(c), "height", true), - "block_by_hash": rpcserver.NewRPCFunc(makeBlockByHashFunc(c), "hash", true), - "block_results": rpcserver.NewRPCFunc(makeBlockResultsFunc(c), "height", true), - "commit": rpcserver.NewRPCFunc(makeCommitFunc(c), "height", true), - "tx": rpcserver.NewRPCFunc(makeTxFunc(c), "hash,prove", true), - "tx_search": rpcserver.NewRPCFunc(makeTxSearchFunc(c), "query,prove,page,per_page,order_by", false), - "block_search": rpcserver.NewRPCFunc(makeBlockSearchFunc(c), "query,page,per_page,order_by", false), - "validators": rpcserver.NewRPCFunc(makeValidatorsFunc(c), "height,page,per_page", true), - "dump_consensus_state": rpcserver.NewRPCFunc(makeDumpConsensusStateFunc(c), "", false), - "consensus_state": rpcserver.NewRPCFunc(makeConsensusStateFunc(c), "", false), - "consensus_params": rpcserver.NewRPCFunc(makeConsensusParamsFunc(c), "height", true), - "unconfirmed_txs": rpcserver.NewRPCFunc(makeUnconfirmedTxsFunc(c), "limit", false), - "num_unconfirmed_txs": rpcserver.NewRPCFunc(makeNumUnconfirmedTxsFunc(c), "", false), + "health": rpcserver.NewRPCFunc(makeHealthFunc(c), ""), + "status": rpcserver.NewRPCFunc(makeStatusFunc(c), ""), + "net_info": rpcserver.NewRPCFunc(makeNetInfoFunc(c), ""), + "blockchain": rpcserver.NewRPCFunc(makeBlockchainInfoFunc(c), "minHeight,maxHeight"), + "genesis": rpcserver.NewRPCFunc(makeGenesisFunc(c), ""), + "genesis_chunked": rpcserver.NewRPCFunc(makeGenesisChunkedFunc(c), ""), + "header": rpcserver.NewRPCFunc(makeHeaderFunc(c), "height"), + "header_by_hash": rpcserver.NewRPCFunc(makeHeaderByHashFunc(c), "hash"), + "block": rpcserver.NewRPCFunc(makeBlockFunc(c), "height"), + "block_by_hash": rpcserver.NewRPCFunc(makeBlockByHashFunc(c), "hash"), + "block_results": rpcserver.NewRPCFunc(makeBlockResultsFunc(c), "height"), + "commit": rpcserver.NewRPCFunc(makeCommitFunc(c), "height"), + "tx": rpcserver.NewRPCFunc(makeTxFunc(c), "hash,prove"), + "tx_search": rpcserver.NewRPCFunc(makeTxSearchFunc(c), "query,prove,page,per_page,order_by"), + "block_search": rpcserver.NewRPCFunc(makeBlockSearchFunc(c), "query,page,per_page,order_by"), + "validators": rpcserver.NewRPCFunc(makeValidatorsFunc(c), "height,page,per_page"), + "dump_consensus_state": rpcserver.NewRPCFunc(makeDumpConsensusStateFunc(c), ""), + "consensus_state": rpcserver.NewRPCFunc(makeConsensusStateFunc(c), ""), + "consensus_params": rpcserver.NewRPCFunc(makeConsensusParamsFunc(c), "height"), + "unconfirmed_txs": rpcserver.NewRPCFunc(makeUnconfirmedTxsFunc(c), "limit"), + "num_unconfirmed_txs": rpcserver.NewRPCFunc(makeNumUnconfirmedTxsFunc(c), ""), // tx broadcast API - "broadcast_tx_commit": rpcserver.NewRPCFunc(makeBroadcastTxCommitFunc(c), "tx", false), - "broadcast_tx_sync": rpcserver.NewRPCFunc(makeBroadcastTxSyncFunc(c), "tx", false), - "broadcast_tx_async": rpcserver.NewRPCFunc(makeBroadcastTxAsyncFunc(c), "tx", false), + "broadcast_tx_commit": rpcserver.NewRPCFunc(makeBroadcastTxCommitFunc(c), "tx"), + "broadcast_tx_sync": rpcserver.NewRPCFunc(makeBroadcastTxSyncFunc(c), "tx"), + "broadcast_tx_async": rpcserver.NewRPCFunc(makeBroadcastTxAsyncFunc(c), "tx"), // abci API - "abci_query": rpcserver.NewRPCFunc(makeABCIQueryFunc(c), "path,data,height,prove", false), - "abci_info": rpcserver.NewRPCFunc(makeABCIInfoFunc(c), "", true), + "abci_query": rpcserver.NewRPCFunc(makeABCIQueryFunc(c), "path,data,height,prove"), + "abci_info": rpcserver.NewRPCFunc(makeABCIInfoFunc(c), ""), // evidence API - "broadcast_evidence": rpcserver.NewRPCFunc(makeBroadcastEvidenceFunc(c), "evidence", false), + "broadcast_evidence": rpcserver.NewRPCFunc(makeBroadcastEvidenceFunc(c), "evidence"), } } diff --git a/rpc/jsonrpc/jsonrpc_test.go b/rpc/jsonrpc/jsonrpc_test.go index 3ad0599ed..002e0b6ab 100644 --- a/rpc/jsonrpc/jsonrpc_test.go +++ b/rpc/jsonrpc/jsonrpc_test.go @@ -53,11 +53,11 @@ type ResultEchoDataBytes struct { // Define some routes var Routes = map[string]*server.RPCFunc{ - "echo": server.NewRPCFunc(EchoResult, "arg", false), + "echo": server.NewRPCFunc(EchoResult, "arg"), "echo_ws": server.NewWSRPCFunc(EchoWSResult, "arg"), - "echo_bytes": server.NewRPCFunc(EchoBytesResult, "arg", false), - "echo_data_bytes": server.NewRPCFunc(EchoDataBytesResult, "arg", false), - "echo_int": server.NewRPCFunc(EchoIntResult, "arg", false), + "echo_bytes": server.NewRPCFunc(EchoBytesResult, "arg"), + "echo_data_bytes": server.NewRPCFunc(EchoDataBytesResult, "arg"), + "echo_int": server.NewRPCFunc(EchoIntResult, "arg"), } func EchoResult(ctx context.Context, v string) (*ResultEcho, error) { diff --git a/rpc/jsonrpc/server/http_json_handler.go b/rpc/jsonrpc/server/http_json_handler.go index 6111aa084..a66e61933 100644 --- a/rpc/jsonrpc/server/http_json_handler.go +++ b/rpc/jsonrpc/server/http_json_handler.go @@ -53,12 +53,7 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han return } - // Set the default response cache to true unless - // 1. Any RPC request rrror. - // 2. Any RPC request doesn't allow to be cached. - // 3. Any RPC request has the height argument and the value is 0 (the default). var responses []rpctypes.RPCResponse - mayCache := true for _, req := range requests { // Ignore notifications, which this service does not support. if req.ID == nil { @@ -69,25 +64,16 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han rpcFunc, ok := funcMap[req.Method] if !ok || rpcFunc.ws { responses = append(responses, rpctypes.RPCMethodNotFoundError(req.ID)) - mayCache = false continue } - if !rpcFunc.cache { - mayCache = false - } args, err := parseParams(rpcFunc, hreq, req) if err != nil { responses = append(responses, rpctypes.RPCInvalidParamsError( req.ID, fmt.Errorf("converting JSON parameters: %w", err))) - mayCache = false continue } - if hasDefaultHeight(req, args) { - mayCache = false - } - returns := rpcFunc.f.Call(args) logger.Debug("HTTPJSONRPC", "method", req.Method, "args", args, "returns", returns) result, err := unreflectResult(returns) @@ -99,24 +85,21 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han // if this already of type RPC error then forward that error case *rpctypes.RPCError: responses = append(responses, rpctypes.NewRPCErrorResponse(req.ID, e.Code, e.Message, e.Data)) - mayCache = false default: // we need to unwrap the error and parse it accordingly switch errors.Unwrap(err) { // check if the error was due to an invald request case coretypes.ErrZeroOrNegativeHeight, coretypes.ErrZeroOrNegativePerPage, coretypes.ErrPageOutOfRange, coretypes.ErrInvalidRequest: responses = append(responses, rpctypes.RPCInvalidRequestError(req.ID, err)) - mayCache = false // lastly default all remaining errors as internal errors default: // includes ctypes.ErrHeightNotAvailable and ctypes.ErrHeightExceedsChainHead responses = append(responses, rpctypes.RPCInternalError(req.ID, err)) - mayCache = false } } } if len(responses) > 0 { - if wErr := WriteRPCResponseHTTP(w, mayCache, responses...); wErr != nil { + if wErr := WriteRPCResponseHTTP(w, responses...); wErr != nil { logger.Error("failed to write responses", "err", wErr) } } @@ -288,12 +271,3 @@ func writeListOfEndpoints(w http.ResponseWriter, r *http.Request, funcMap map[st w.WriteHeader(200) w.Write(buf.Bytes()) // nolint: errcheck } - -func hasDefaultHeight(r rpctypes.RPCRequest, h []reflect.Value) bool { - switch r.Method { - case "block", "block_results", "commit", "consensus_params", "validators": - return len(h) < 2 || h[1].IsZero() - default: - return false - } -} diff --git a/rpc/jsonrpc/server/http_json_handler_test.go b/rpc/jsonrpc/server/http_json_handler_test.go index 8c53a3747..92ad1435c 100644 --- a/rpc/jsonrpc/server/http_json_handler_test.go +++ b/rpc/jsonrpc/server/http_json_handler_test.go @@ -18,8 +18,8 @@ import ( func testMux() *http.ServeMux { funcMap := map[string]*RPCFunc{ - "c": NewRPCFunc(func(ctx context.Context, s string, i int) (string, error) { return "foo", nil }, "s,i", false), - "block": NewRPCFunc(func(ctx context.Context, h int) (string, error) { return "block", nil }, "height", true), + "c": NewRPCFunc(func(ctx context.Context, s string, i int) (string, error) { return "foo", nil }, "s,i"), + "block": NewRPCFunc(func(ctx context.Context, h int) (string, error) { return "block", nil }, "height"), } mux := http.NewServeMux() logger := log.NewNopLogger() @@ -238,7 +238,7 @@ func TestRPCResponseCache(t *testing.T) { // Always expecting back a JSONRPCResponse require.True(t, statusOK(res.StatusCode), "should always return 2XX") - require.Equal(t, "max-age=31536000", res.Header.Get("Cache-control")) + require.Equal(t, "", res.Header.Get("Cache-control")) _, err := io.ReadAll(res.Body) res.Body.Close() diff --git a/rpc/jsonrpc/server/http_server.go b/rpc/jsonrpc/server/http_server.go index 5d6b3a355..a9a5ca0b8 100644 --- a/rpc/jsonrpc/server/http_server.go +++ b/rpc/jsonrpc/server/http_server.go @@ -169,7 +169,7 @@ func WriteRPCResponseHTTPError( // WriteRPCResponseHTTP marshals res as JSON (with indent) and writes it to w. // If the rpc response can be cached, add cache-control to the response header. -func WriteRPCResponseHTTP(w http.ResponseWriter, c bool, res ...rpctypes.RPCResponse) error { +func WriteRPCResponseHTTP(w http.ResponseWriter, res ...rpctypes.RPCResponse) error { var v interface{} if len(res) == 1 { v = res[0] @@ -182,10 +182,7 @@ func WriteRPCResponseHTTP(w http.ResponseWriter, c bool, res ...rpctypes.RPCResp return fmt.Errorf("json marshal: %w", err) } w.Header().Set("Content-Type", "application/json") - if c { - w.Header().Set("Cache-Control", "max-age=31536000") // expired after one year - } - w.WriteHeader(200) + w.WriteHeader(http.StatusOK) _, err = w.Write(jsonBytes) return err } @@ -225,7 +222,7 @@ func RecoverAndLogHandler(handler http.Handler, logger log.Logger) http.Handler // If RPCResponse if res, ok := e.(rpctypes.RPCResponse); ok { - if wErr := WriteRPCResponseHTTP(rww, false, res); wErr != nil { + if wErr := WriteRPCResponseHTTP(rww, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } } else { diff --git a/rpc/jsonrpc/server/http_server_test.go b/rpc/jsonrpc/server/http_server_test.go index c546f82fc..7c114e62a 100644 --- a/rpc/jsonrpc/server/http_server_test.go +++ b/rpc/jsonrpc/server/http_server_test.go @@ -122,7 +122,7 @@ func TestWriteRPCResponseHTTP(t *testing.T) { // one argument w := httptest.NewRecorder() - err := WriteRPCResponseHTTP(w, true, rpctypes.NewRPCSuccessResponse(id, &sampleResult{"hello"})) + err := WriteRPCResponseHTTP(w, rpctypes.NewRPCSuccessResponse(id, &sampleResult{"hello"})) require.NoError(t, err) resp := w.Result() body, err := io.ReadAll(resp.Body) @@ -130,7 +130,7 @@ func TestWriteRPCResponseHTTP(t *testing.T) { require.NoError(t, err) assert.Equal(t, 200, resp.StatusCode) assert.Equal(t, "application/json", resp.Header.Get("Content-Type")) - assert.Equal(t, "max-age=31536000", resp.Header.Get("Cache-control")) + assert.Equal(t, "", resp.Header.Get("Cache-control")) assert.Equal(t, `{ "jsonrpc": "2.0", "id": -1, @@ -142,9 +142,9 @@ func TestWriteRPCResponseHTTP(t *testing.T) { // multiple arguments w = httptest.NewRecorder() err = WriteRPCResponseHTTP(w, - false, rpctypes.NewRPCSuccessResponse(id, &sampleResult{"hello"}), - rpctypes.NewRPCSuccessResponse(id, &sampleResult{"world"})) + rpctypes.NewRPCSuccessResponse(id, &sampleResult{"world"}), + ) require.NoError(t, err) resp = w.Result() body, err = io.ReadAll(resp.Body) diff --git a/rpc/jsonrpc/server/http_uri_handler.go b/rpc/jsonrpc/server/http_uri_handler.go index d9e8b0cbb..fcdfc707a 100644 --- a/rpc/jsonrpc/server/http_uri_handler.go +++ b/rpc/jsonrpc/server/http_uri_handler.go @@ -62,7 +62,7 @@ func makeHTTPHandler(rpcFunc *RPCFunc, logger log.Logger) func(http.ResponseWrit // if no error then return a success response case nil: res := rpctypes.NewRPCSuccessResponse(dummyID, result) - if wErr := WriteRPCResponseHTTP(w, rpcFunc.cache, res); wErr != nil { + if wErr := WriteRPCResponseHTTP(w, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } diff --git a/rpc/jsonrpc/server/parse_test.go b/rpc/jsonrpc/server/parse_test.go index ceb0e2020..0b8f45e6d 100644 --- a/rpc/jsonrpc/server/parse_test.go +++ b/rpc/jsonrpc/server/parse_test.go @@ -135,7 +135,7 @@ func TestParseJSONArray(t *testing.T) { func TestParseJSONRPC(t *testing.T) { demo := func(ctx context.Context, height int, name string) {} - call := NewRPCFunc(demo, "height,name", false) + call := NewRPCFunc(demo, "height,name") cases := []struct { raw string @@ -172,7 +172,7 @@ func TestParseJSONRPC(t *testing.T) { func TestParseURI(t *testing.T) { demo := func(ctx context.Context, height int, name string) {} - call := NewRPCFunc(demo, "height,name", false) + call := NewRPCFunc(demo, "height,name") cases := []struct { raw []string diff --git a/rpc/jsonrpc/server/rpc_func.go b/rpc/jsonrpc/server/rpc_func.go index 24f3c8976..17e72cb10 100644 --- a/rpc/jsonrpc/server/rpc_func.go +++ b/rpc/jsonrpc/server/rpc_func.go @@ -31,22 +31,20 @@ type RPCFunc struct { returns []reflect.Type // type of each return arg argNames []string // name of each argument ws bool // websocket only - cache bool // allow the RPC response can be cached by the proxy cache server } // NewRPCFunc wraps a function for introspection. // f is the function, args are comma separated argument names -// cache is a bool value to allow the client proxy server to cache the RPC results -func NewRPCFunc(f interface{}, args string, cache bool) *RPCFunc { - return newRPCFunc(f, args, false, cache) +func NewRPCFunc(f interface{}, args string) *RPCFunc { + return newRPCFunc(f, args, false) } // NewWSRPCFunc wraps a function for introspection and use in the websockets. func NewWSRPCFunc(f interface{}, args string) *RPCFunc { - return newRPCFunc(f, args, true, false) + return newRPCFunc(f, args, true) } -func newRPCFunc(f interface{}, args string, ws bool, c bool) *RPCFunc { +func newRPCFunc(f interface{}, args string, ws bool) *RPCFunc { var argNames []string if args != "" { argNames = strings.Split(args, ",") @@ -57,7 +55,6 @@ func newRPCFunc(f interface{}, args string, ws bool, c bool) *RPCFunc { returns: funcReturnTypes(f), argNames: argNames, ws: ws, - cache: c, } } diff --git a/rpc/jsonrpc/test/main.go b/rpc/jsonrpc/test/main.go index 524acc383..231b2bb5b 100644 --- a/rpc/jsonrpc/test/main.go +++ b/rpc/jsonrpc/test/main.go @@ -13,7 +13,7 @@ import ( ) var routes = map[string]*rpcserver.RPCFunc{ - "hello_world": rpcserver.NewRPCFunc(HelloWorld, "name,num", false), + "hello_world": rpcserver.NewRPCFunc(HelloWorld, "name,num"), } func HelloWorld(ctx context.Context, name string, num int) (Result, error) { diff --git a/test/fuzz/rpc/jsonrpc/server/handler.go b/test/fuzz/rpc/jsonrpc/server/handler.go index 61779b7f4..976174092 100644 --- a/test/fuzz/rpc/jsonrpc/server/handler.go +++ b/test/fuzz/rpc/jsonrpc/server/handler.go @@ -13,7 +13,7 @@ import ( ) var rpcFuncMap = map[string]*rs.RPCFunc{ - "c": rs.NewRPCFunc(func(s string, i int) (string, int) { return "foo", 200 }, "s,i", false), + "c": rs.NewRPCFunc(func(s string, i int) (string, int) { return "foo", 200 }, "s,i"), } var mux *http.ServeMux