diff --git a/agent/internal/clients/client.go b/agent/internal/clients/client.go index cbb45aa11..215018cbb 100644 --- a/agent/internal/clients/client.go +++ b/agent/internal/clients/client.go @@ -9,6 +9,7 @@ import ( "fmt" "io" "net/http" + "net/http/httptrace" "strings" "time" ) @@ -73,28 +74,43 @@ func (c Client) Do(ctx context.Context, method, path string, body any) (*Respons return nil, err } } - req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(c.BaseURL, "/")+path, bytes.NewReader(encoded)) - if err != nil { - return nil, errors.New("invalid provider request") - } - req.Header = c.Headers.Clone() - if req.Header == nil { - req.Header = make(http.Header) - } - req.Header.Set("Accept", "application/json") - if body != nil { - req.Header.Set("Content-Type", "application/json") - } client := c.HTTP if client == nil { client = &http.Client{Timeout: 10 * time.Second} } - response, err := client.Do(req) - if err != nil { + var response *http.Response + // A request the transport began sending but never wrote, e.g. because the + // connection failed during setup, had no effect, so it is resent once + // whatever its method. A transport that reports neither is ambiguous. + for attempt := 0; ; attempt++ { + connecting, written := false, false + trace := &httptrace.ClientTrace{ + GetConn: func(string) { connecting = true }, + WroteHeaders: func() { written = true }, + WroteRequest: func(httptrace.WroteRequestInfo) { written = true }, + } + req, err := http.NewRequestWithContext(httptrace.WithClientTrace(ctx, trace), method, strings.TrimRight(c.BaseURL, "/")+path, bytes.NewReader(encoded)) + if err != nil { + return nil, errors.New("invalid provider request") + } + req.Header = c.Headers.Clone() + if req.Header == nil { + req.Header = make(http.Header) + } + req.Header.Set("Accept", "application/json") + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + response, err = client.Do(req) + if err == nil { + break + } if ctx.Err() != nil { return nil, ctx.Err() } - return nil, errors.New("provider transport failure") + if !connecting || written || attempt == 1 { + return nil, errors.New("provider transport failure") + } } defer response.Body.Close() data, err := io.ReadAll(io.LimitReader(response.Body, (8<<20)+1)) diff --git a/agent/internal/clients/unsent_test.go b/agent/internal/clients/unsent_test.go new file mode 100644 index 000000000..f6905060a --- /dev/null +++ b/agent/internal/clients/unsent_test.go @@ -0,0 +1,60 @@ +package clients + +import ( + "context" + "io" + "net" + "net/http" + "net/http/httptest" + "sync/atomic" + "testing" +) + +// dropFirst closes the first connection it accepts before the TLS handshake +// finishes, as a reset during connection setup does. +type dropFirst struct { + net.Listener + accepted atomic.Int32 +} + +func (l *dropFirst) Accept() (net.Conn, error) { + for { + conn, err := l.Listener.Accept() + if err != nil || l.accepted.Add(1) > 1 { + return conn, err + } + conn.Close() + } +} + +// A request that never reached the provider has no effect, so even a chat +// POST is safe to send again; one the provider may have received is not. +func TestDoResendsRequestsThatWereNeverWritten(t *testing.T) { + var received atomic.Int32 + server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + received.Add(1) + io.WriteString(w, `{}`) + })) + server.Listener = &dropFirst{Listener: server.Listener} + server.StartTLS() + defer server.Close() + client := Client{HTTP: server.Client(), BaseURL: server.URL} + response, err := client.Do(context.Background(), http.MethodPost, "/chat/messages", map[string]string{"message": "hi"}) + if err != nil || response.StatusCode != 200 || received.Load() != 1 { + t.Fatalf("err=%v received=%d", err, received.Load()) + } +} + +func TestDoDoesNotResendWrittenRequests(t *testing.T) { + var received atomic.Int32 + server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + received.Add(1) + conn, _, _ := w.(http.Hijacker).Hijack() + conn.Close() // received, but no response: the outcome is unknown + })) + defer server.Close() + client := Client{HTTP: server.Client(), BaseURL: server.URL} + if _, err := client.Do(context.Background(), http.MethodPost, "/chat/messages", map[string]string{"message": "hi"}); err == nil || received.Load() != 1 { + t.Fatalf("err=%v received=%d; an ambiguous POST was resent", err, received.Load()) + } +}