What is http.Request.GetBody, and which body types make net/http fill it in?

## What the field is for ```go type Request struct { Body io.ReadCloser GetBody func() (io.ReadCloser, error) // ... } ``` `Body` is the one-shot stream that gets written to the connection. `GetBody` is the recipe for making another one. Every call to it must return a reader positioned at the start of the same payload, independent of any reader handed out before. It is the single place in `net/http` where "this request can be sent more than once" is expressed as data rather than as a comment. ## When the constructor fills it in `http.NewRequest(method, url string, body io.Reader)` and its context-carrying twin `http.NewRequestWithContext(ctx, method, url, body)` inspect the dynamic type of `body`. For exactly three standard-library types — `*bytes.Buffer`, `*bytes.Reader` and `*strings.Reader` — they can ask the value for its remaining length, so they set `ContentLength` and install a `GetBody` closure that reconstructs a reader over the same underlying bytes. As a small extra: when such a body is empty, the constructor sets `Body` to `http.NoBody` rather than a live reader. For anything else the constructor cannot know the length without consuming the stream, and it will not do that behind your back. So `ContentLength` is left at 0 — which, for a client request with a non-nil body, means *unknown* and results in chunked transfer encoding — and `GetBody` is left nil. This is why the three types matter in practice: the difference between `bytes.NewReader(payload)` and `io.NopCloser(bytes.NewReader(payload))` is the difference between a replayable request and an unreplayable one, even though both wrap the same bytes. ## Who calls it besides your code Two parts of `net/http` use `GetBody` on your behalf. The `Client` uses it when it has to reissue a request, and the `Transport` uses it when a request fails on a connection it had picked out of its idle set — a connection the server may have closed while it sat idle. That transport-level retry is deliberately conservative: it only happens when the request is replayable (`Body` nil, or `GetBody` non-nil) *and* the method is one of GET, HEAD, OPTIONS or TRACE, or the request carries an idempotency header. It is not a general retry facility, and you should not count on it as one — it exists to paper over stale pooled connections, not over a failing server. ## Setting it yourself When you construct the body some other way, wire both fields explicitly: ```go req.ContentLength = int64(len(payload)) req.GetBody = func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(payload)), nil } req.Body, _ = req.GetBody() ``` Note that `Body` itself is just the first product of `GetBody`. Writing it this way makes it structurally impossible for the two to disagree, which is the failure mode when someone sets `GetBody` but leaves `Body` pointing at a different reader. The closure must be safe to call repeatedly and must not depend on state the previous attempt mutated. Capturing an immutable `[]byte` is the easy correct case. Capturing an `*os.File` and calling `Seek(0, io.SeekStart)` inside the closure works too, but only while the file is still open and unmodified — which is exactly the kind of assumption that breaks when a retry happens minutes later. ## Using it in a retry loop A delivery worker that wants to attempt the same POST several times can either rebuild the whole request or clone it and refresh the body: ```go attempt := req.Clone(ctx) if req.GetBody != nil { body, err := req.GetBody() if err != nil { return err } attempt.Body = body } ``` `Request.Clone` gives you a deep-enough copy that the Transport's mutations on one attempt do not leak into the next, and the `GetBody != nil` check is the honest guard: if the caller handed you an unbuffered stream, you cannot retry, and the right behaviour is to say so rather than to send a truncated payload. ## The rule to remember `Body` is the bytes for this attempt. `GetBody` is the promise that there can be another attempt. If it is nil, the request is single-use, and no amount of retry logic above it can change that.