Method RoundTrip

coderd/aibridged/transport.go:62–154

(req *http.Request)

}

func (t *inMemoryRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	// The in-process transport requires the caller to have placed the
	// delegated API key ID on the context. Without it, aibridged has no
	// identity to act under. Fail fast at the transport boundary so the
	// handler can assume the invariant.
	if _, ok := aibridge.DelegatedAPIKeyIDFromContext(req.Context()); !ok {
		return nil, xerrors.New("aibridged in-memory transport requires WithDelegatedAPIKeyID on the request context")
	}

	// Adapt the caller's upstream-shaped URL to the daemon's mount layout:
	// "/api/v2/aibridge/<providerName>/<original-path>". Done here so
	// callers do not need to encode the mount prefix or the provider
	// routing key into the requests they hand to the transport.
	newPath, err := url.JoinPath(aibridgeRootPath, t.providerName, req.URL.Path)
	if err != nil {
		return nil, xerrors.Errorf("rewrite request URL for provider %q: %w", t.providerName, err)
	}
	req = req.Clone(req.Context())
	req.URL.Path = newPath

	pr, pw := io.Pipe()
	rw := &pipeResponseWriter{
		header:     http.Header{},
		body:       pw,
		gotHeaders: make(chan struct{}),
		status:     http.StatusOK,
	}

	// Cloning preserves caller-supplied headers and context but lets the
	// handler operate on its own request value without surprising the caller
	// if it mutates Headers or stores the request. The Source is attached to
	// the served context so downstream handlers can log the call site.
	served := req.Clone(aibridge.WithSource(req.Context(), t.source))

	handlerDone := make(chan struct{})
	go func() {
		defer func() {
			if r := recover(); r != nil {
				// Mirror net/http.Server behavior: a panicking handler
				// produces a 500 instead of crashing the process.
				rw.WriteHeader(http.StatusInternalServerError)
				_ = pw.CloseWithError(xerrors.Errorf("handler panicked: %v", r))
			}
			// Make sure we always unblock RoundTrip even if the handler
			// returns before writing headers (e.g. handler returns early
			// without writing).
			rw.ensureHeaders()
			// If the request context was canceled, surface that as a
			// body-read error so the caller sees a network-style failure
			// rather than EOF. Otherwise close cleanly.
			if cerr := served.Context().Err(); cerr != nil {
				_ = pw.CloseWithError(cerr)
			} else {
				_ = pw.Close()
			}
			close(handlerDone)
		}()
		t.handler.ServeHTTP(rw, served)