Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 31 additions & 15 deletions agent/internal/clients/client.go
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@ import (
"fmt"
"io"
"net/http"
"net/http/httptrace"
"strings"
"time"
)
Expand Down Expand Up @@ -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))
Expand Down
60 changes: 60 additions & 0 deletions agent/internal/clients/unsent_test.go
Original file line number Diff line number Diff line change
@@ -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())
}
}
Loading