rpc: add limit for batch request and response size

[mmsqe]

This PR adds server-side limits for JSON-RPC batch requests. Before this change, batches
were limited only by processing time. The server would pick calls from the batch and
answer them until the response timeout occurred, then stop processing the remaining batch
items.

Here, we are adding two additional limits which can be configured:

• the 'item limit': batches can have at most N items
• the 'response size limit': batches can contain at most X response bytes

These limits are optional in package rpc. In Geth, we set a default limit of 1000 items
and 25MB response size.

When a batch goes over the limit, an error response is returned to the client. However,
doing this correctly isn't always possible. In JSON-RPC, only method calls with a valid
id can be responded to. Since batches may also contain non-call messages or
notifications, the best effort thing we can do to report an error with the batch itself is
reporting the limit violation as an error for the first method call in the batch. If a batch is
too large, but contains only notifications and responses, the error will be reported with
a null id.

The RPC client was also changed so it can deal with errors resulting from too large
batches. An older client connected to the server code in this PR could get stuck
until the request timeout occurred when the batch is too large. Upgrading to a version
of the RPC client containing this change is strongly recommended to avoid timeout issues.

For some weird reason, when writing the original client implementation, @fjl worked off of
the assumption that responses could be distributed across batches arbitrarily. So for a
batch request containing requests [A B C], the server could respond with [A B C] but
also with [A B] [C] or even [A] [B] [C] and it wouldn't make a difference to the
client.

So in the implementation of BatchCallContext, the client waited for all requests in the
batch individually. If the server didn't respond to some of the requests in the batch, the
client would eventually just time out (if a context was used).

With the addition of batch limits into the server, we anticipate that people will hit this
kind of error way more often. To handle this properly, the client now waits for a single
response batch and expects it to contain all responses to the requests.

[fjl]

This looks very good!

I think it would be better to make these limits configurable somehow. My suggestion for that would be a method like SetBatchLimits(length int, size int) on Server and Client.

[mmsqe]

This looks very good!

I think it would be better to make these limits configurable somehow. My suggestion for that would be a method like SetBatchLimits(length int, size int) on Server and Client.

Since the limit make more sense to add in server side, I only move set batch limit related change in Server and keep Client unchanged.

[fjl]

The client can also accept requests from the server (and the server is implemented using Client) :)

[mmsqe]

The client can also accept requests from the server (and the server is implemented using Client) :)

May I ask how to add config to Client, which doesn't have access to this config right? And newClient would have breaking change by adding new params.

[holiman]

IMO these flags should be somwhere in the rpc. namespace

[fjl]

I was finally able to fix this up properly. With the latest changes, the client will now properly handle wrong size batch responses and return early without relying on the timeout.

[fjl]

@holiman PTAL

[holiman]

Still LGTM