Tinygo crashes on `http.Client{}.Do()` with Timeout

[Darckfast]

client.Do() a crashes When creating a new http.Client{} with timeout

net/http/client.go

Lines 433 to 439 in 1026408

	func (c *Client) Do(req *Request) (*Response, error) {
	if c.Transport != nil {
	return c.Transport.RoundTrip(req)
	}
	return c.do(req)
	}

net/http/client.go

Line 461 in 1026408

if !deadline.IsZero() && didTimeout() {

Seems like the when creating a client the transport is nil, which causes the .Do() to use tls.Dial, which returns an error, but the func didTimeout is never initialized like on net/http in Go https://github.com/golang/go/blob/d00c67f297ef6f2cb2cd0e9aae59fa3936bb7eca/src/net/http/client.go#L264

Error

❯ ./app
panic: runtime error at 0x000000000024bd02: nil pointer dereference
fish: Job 1, './app' terminated by signal SIGABRT (Abort)

POC

package main

import (
	"log"
	"net/http"
	"time"
)

func main() {
	c := http.Client{
		Timeout: 2 * time.Second,
	}

	rs, _ := http.NewRequest("GET", "https://google.com", nil)
	r, e := c.Do(rs)

	if e != nil {
		log.Println(e)
	} else {
		log.Println(r.Status)
	}
}

[Nico-Mayer]

It seems that, at the moment, there is no way to cancel an in-flight request. Any http.Get or http.Post to an unreachable destination blocks indefinitely, effectively deadlocking the entire process and requiring a manual reset.

[Darckfast]

yeah, i gave a shot porting Go's timeout solution and it seems to work fine, might bring this here

[Nico-Mayer]

yeah, i gave a shot porting Go's timeout solution and it seems to work fine, might bring this here

Could you please share your solution? I’m curious to know how you approached it.

[Darckfast]

Could you please share your solution? I’m curious to know how you approached it.

ofc, it's nothing too amazing, i just grabbed Go net/http/client.go code and removed some part like http2 and legacy CancelRequest (Go 1.6)

//net/http/client.go
// setRequestCancel sets req.Cancel and adds a deadline context to req
// if deadline is non-zero. The RoundTripper's type is used to
// determine whether the legacy CancelRequest behavior should be used.
//
// As background, there are three ways to cancel a request:
// First was Transport.CancelRequest. (deprecated)
// Second was Request.Cancel.
// Third was Request.Context.
// This function populates the second and third, and uses the first if it really needs to.  TINYGO: Removed the third option as we dont support Go 1.6
func setRequestCancel(req *Request, rt RoundTripper, deadline time.Time) (stopTimer func(), didTimeout func() bool) {
	if deadline.IsZero() {
		return nop, alwaysFalse
	}
	knownTransport := knownRoundTripperImpl(rt, req) // switch that check if rt.(type) is *Transport
	oldCtx := req.Context()

	if req.Cancel == nil && knownTransport {
		// If they already had a Request.Context that's
		// expiring sooner, do nothing:
		if !timeBeforeContextDeadline(deadline, oldCtx) {
			return nop, alwaysFalse
		}

		var cancelCtx func()
		req.ctx, cancelCtx = context.WithDeadline(oldCtx, deadline)
		return cancelCtx, func() bool { return time.Now().After(deadline) }
	}
	initialReqCancel := req.Cancel // the user's original Request.Cancel, if any

	var cancelCtx func()
	if timeBeforeContextDeadline(deadline, oldCtx) { // timeBeforeContextDeadline checks if ctx.Deadline() is before deadline
		req.ctx, cancelCtx = context.WithDeadline(oldCtx, deadline)
	}

	cancel := make(chan struct{})
	req.Cancel = cancel

	doCancel := func() {
		// The second way in the func comment above:
		close(cancel)
		// TINYGO: Removed logic using CancelRequest (implementation for <= Go 1.6)
	}

	stopTimerCh := make(chan struct{})
	stopTimer = sync.OnceFunc(func() {
		close(stopTimerCh)
		if cancelCtx != nil {
			cancelCtx()
		}
	})

	timer := time.NewTimer(time.Until(deadline))
	var timedOut atomic.Bool

	go func() {
		select {
		case <-initialReqCancel:
			doCancel()
			timer.Stop()
		case <-timer.C:
			timedOut.Store(true)
			doCancel()
		case <-stopTimerCh:
			timer.Stop()
		}
	}()

	return stopTimer, timedOut.Load
}

then on roundtrip i added this before writing to the connection

ctx, cancel := context.WithCancelCause(req.Context())
defer func() {
	if err != nil {
		cancel(err)
	}
}()

// TINYGO: TODO handle timeouts
select {
case <-ctx.Done():
	req.closeBody()
	return nil, context.Cause(ctx)
default:
}

the setRequestCancel() get called a line before calling the roundTrip() in the send() function

stopTimer, didTimeout := setRequestCancel(req, rt, deadline)

resp, err = rt.RoundTrip(req)

i still need to test with tinygo own roundTrip(), but for JS roundTrip it works fine

there is more code, like the error types, extra helper functions on transport and client, but the part above is the gist of it

[0pcom]

This is fixed on main by 70037cf ("net/http: fix nil didTimeout deref when a client dial fails"): send now returns an alwaysFalse func on the error path, so c.do's didTimeout() call no longer dereferences a nil func value when the dial fails with Client.Timeout set.

Relatedly, #83 (open) makes the nil-Transport client dispatch through DefaultTransport / the fetch API on js/wasm instead of always dialing through the netdev — the other half of what your POC runs into (#66). With main as of 70037cf your reproducer should report the dial error instead of panicking; worth a re-test and closing if it checks out.