Merge pull request #129 from dotindustries/feat/patch-netdial-dns-resolution-via-warpgrid-shim-bye1t93yco4s503zgcoqdqn7

feat: patch net.Dial DNS resolution via WarpGrid shim

Author: tervezo-ai[bot]

crates/warpgrid-host/tests/integration_go_dns_dial.rs

@@ -62,7 +62,7 @@ func (d *Dialer) Dial(network, address string) (net.Conn, error) {
 		return nil, &net.OpError{
 			Op:  "dial",
 			Net: network,
-			Err: &net.DNSError{
+			Err: &DNSError{
 				Err:        err.Error(),
 				Name:       host,
 				IsNotFound: true,
@@ -74,7 +74,7 @@ func (d *Dialer) Dial(network, address string) (net.Conn, error) {
 		return nil, &net.OpError{
 			Op:  "dial",
 			Net: network,
-			Err: &net.DNSError{
+			Err: &DNSError{
 				Err:        "no addresses found",
 				Name:       host,
 				IsNotFound: true,

packages/warpgrid-go/net/dial.go

@@ -0,0 +1,30 @@
+// Non-WASI fallback convenience functions for DNS-aware dialing.
+//
+// On standard Go (non-WASI), there is no WarpGrid DNS shim backend.
+// These functions fall through to the standard library's net.Dial so
+// that code importing this package compiles and works in native
+// development and testing environments.
+
+//go:build !wasip1 && !wasip2
+
+package net
+
+import (
+	"net"
+	"time"
+)
+
+// Dial connects to the address on the named network.
+//
+// On non-WASI targets this delegates directly to net.Dial from the
+// standard library since no WarpGrid DNS shim is available.
+func Dial(network, address string) (net.Conn, error) {
+	return net.Dial(network, address)
+}
+
+// DialTimeout is like Dial but with a connection timeout.
+//
+// On non-WASI targets this delegates to net.DialTimeout.
+func DialTimeout(network, address string, timeout time.Duration) (net.Conn, error) {
+	return net.DialTimeout(network, address, timeout)
+}

packages/warpgrid-go/net/dial_default.go

@@ -387,6 +387,53 @@ func TestDial_DNSErrorContainsHostname(t *testing.T) {
 	}
 }
 
+// ── Package-level Dial() convenience function tests ─────────────────
+
+func TestPackageDial_HostnameResolvedViaDNS(t *testing.T) {
+	// Package-level Dial on non-WASI falls through to net.Dial, so it
+	// won't use the WarpGrid DNS shim.  We test that the function at
+	// least compiles and works with an IP literal (which bypasses DNS
+	// on all platforms).
+	addr, cleanup := startEchoServer(t)
+	defer cleanup()
+
+	conn, err := wgnet.Dial("tcp", addr)
+	if err != nil {
+		t.Fatalf("wgnet.Dial failed: %v", err)
+	}
+	defer conn.Close()
+
+	// Echo round-trip
+	message := "Hello from package-level Dial!"
+	_, err = conn.Write([]byte(message))
+	if err != nil {
+		t.Fatalf("Write failed: %v", err)
+	}
+
+	buf := make([]byte, len(message))
+	_, err = io.ReadFull(conn, buf)
+	if err != nil {
+		t.Fatalf("Read failed: %v", err)
+	}
+
+	if string(buf) != message {
+		t.Fatalf("expected %q, got %q", message, string(buf))
+	}
+}
+
+func TestPackageDialTimeout_RespectsTimeout(t *testing.T) {
+	start := time.Now()
+	_, err := wgnet.DialTimeout("tcp", "192.0.2.1:65535", 200*time.Millisecond)
+	elapsed := time.Since(start)
+
+	if err == nil {
+		t.Fatal("expected error dialing unreachable address")
+	}
+	if elapsed > 5*time.Second {
+		t.Fatalf("DialTimeout not respected: took %v (expected <5s with 200ms timeout)", elapsed)
+	}
+}
+
 // ── ConnectTimeout tests ────────────────────────────────────────────
 
 func TestDial_ConnectTimeoutIsApplied(t *testing.T) {
@@ -433,7 +480,7 @@ func TestDial_DNSFailureWrapsInnerDNSError(t *testing.T) {
 	}
 
 	// The inner error should be *net.DNSError with correct fields
-	var dnsErr *net.DNSError
+	var dnsErr *wgnet.DNSError
 	if !errors.As(opErr.Err, &dnsErr) {
 		t.Fatalf("expected inner *net.DNSError, got %T: %v", opErr.Err, opErr.Err)
 	}
@@ -462,7 +509,7 @@ func TestDial_DNSEmptyResultWrapsInnerDNSError(t *testing.T) {
 		t.Fatalf("expected *net.OpError, got %T: %v", err, err)
 	}
 
-	var dnsErr *net.DNSError
+	var dnsErr *wgnet.DNSError
 	if !errors.As(opErr.Err, &dnsErr) {
 		t.Fatalf("expected inner *net.DNSError, got %T: %v", opErr.Err, opErr.Err)
 	}

packages/warpgrid-go/net/dial_test.go

@@ -0,0 +1,40 @@
+// WASI-specific convenience functions for DNS-aware dialing.
+//
+// On WASI targets, DefaultDialer() returns a Dialer wired to the
+// WarpGrid DNS shim backend. The package-level Dial() and DialTimeout()
+// functions provide a drop-in API that resolves hostnames via the shim
+// before connecting.
+//
+// This file is only compiled when targeting WASI (wasip1 or wasip2).
+
+//go:build wasip1 || wasip2
+
+package net
+
+import (
+	"net"
+	"time"
+
+	"github.com/anthropics/warpgrid/packages/warpgrid-go/dns"
+)
+
+// DefaultDialer returns a Dialer configured with the WASI DNS backend.
+// Use this when you need to customise timeouts or other Dialer fields.
+func DefaultDialer() *Dialer {
+	return NewDialer(dns.DefaultResolver())
+}
+
+// Dial connects to the address on the named network, resolving
+// hostnames via the WarpGrid DNS shim. IP literals bypass DNS.
+//
+// This is the package-level convenience wrapper around DefaultDialer().Dial.
+func Dial(network, address string) (net.Conn, error) {
+	return DefaultDialer().Dial(network, address)
+}
+
+// DialTimeout is like Dial but with a per-address connection timeout.
+func DialTimeout(network, address string, timeout time.Duration) (net.Conn, error) {
+	d := DefaultDialer()
+	d.ConnectTimeout = timeout
+	return d.Dial(network, address)
+}

packages/warpgrid-go/net/dial_wasi.go

@@ -0,0 +1,29 @@
+// DNSError polyfill for environments where net.DNSError is unavailable.
+//
+// TinyGo's net package does not include net.DNSError, so we define a
+// compatible type here. On standard Go, we use net.DNSError directly
+// (see dnserror_std.go). This file is only compiled under TinyGo.
+
+//go:build tinygo
+
+package net
+
+// DNSError represents a DNS lookup failure, compatible with Go's
+// net.DNSError interface. This polyfill is used by TinyGo builds
+// where net.DNSError is not available.
+type DNSError struct {
+	Err        string
+	Name       string
+	IsNotFound bool
+}
+
+func (e *DNSError) Error() string {
+	s := "lookup " + e.Name
+	if e.Err != "" {
+		s += ": " + e.Err
+	}
+	return s
+}
+
+func (e *DNSError) Timeout() bool   { return false }
+func (e *DNSError) Temporary() bool { return false }

packages/warpgrid-go/net/dnserror.go

@@ -0,0 +1,13 @@
+// DNSError alias for standard Go (non-TinyGo) builds.
+//
+// On standard Go, net.DNSError is available directly. We re-export it
+// so that dial.go can use DNSError without conditional imports.
+
+//go:build !tinygo
+
+package net
+
+import "net"
+
+// DNSError is an alias for net.DNSError on standard Go builds.
+type DNSError = net.DNSError

packages/warpgrid-go/net/dnserror_std.go

@@ -0,0 +1,7 @@
+module go-dns-dial-guest
+
+go 1.22.0
+
+require github.com/anthropics/warpgrid/packages/warpgrid-go v0.0.0
+
+replace github.com/anthropics/warpgrid/packages/warpgrid-go => ../../../packages/warpgrid-go

tests/fixtures/go-dns-dial-guest/go-dns-dial-guest.wasm

@@ -0,0 +1,143 @@
+// Package main is a WASI guest fixture that exercises DNS resolution
+// through the WarpGrid DNS shim (warpgrid_shim dns_resolve).
+//
+// Each exported function tests a specific DNS resolution scenario via
+// dns.DefaultResolver(). The host integration test registers a service
+// registry mapping test hostnames to known IPs, then calls these exports
+// and validates the results.
+//
+// Build: tinygo build -target=wasi -buildmode=c-shared -o go-dns-dial-guest.wasm .
+//
+// Reactor mode (-buildmode=c-shared) is required so that //go:wasmexport
+// functions work after _initialize.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+	"unsafe"
+
+	wgdns "github.com/anthropics/warpgrid/packages/warpgrid-go/dns"
+	wgnet "github.com/anthropics/warpgrid/packages/warpgrid-go/net"
+)
+
+func main() {}
+
+// ── Exported test functions ─────────────────────────────────────────
+//
+// Each function returns a packed uint64: high 32 bits = pointer to
+// result string, low 32 bits = length. The host reads the string from
+// linear memory. Format: "OK:<data>" on success, "ERR:<message>" on failure.
+
+// testResolveRegistry resolves a hostname expected to be in the service
+// registry and returns the first resolved IP address.
+//
+//go:wasmexport test-resolve-registry
+func testResolveRegistry() uint64 {
+	resolver := wgdns.DefaultResolver()
+	ips, err := resolver.Resolve("echo-server.test.warp.local")
+	if err != nil {
+		return writeResult(fmt.Sprintf("ERR:resolve failed: %v", err))
+	}
+	if len(ips) == 0 {
+		return writeResult("ERR:no addresses returned")
+	}
+	return writeResult(fmt.Sprintf("OK:%s", ips[0].String()))
+}
+
+// testResolveMultiple resolves a hostname with multiple A records and
+// returns all addresses comma-separated.
+//
+//go:wasmexport test-resolve-multiple
+func testResolveMultiple() uint64 {
+	resolver := wgdns.DefaultResolver()
+	ips, err := resolver.Resolve("multi.test.warp.local")
+	if err != nil {
+		return writeResult(fmt.Sprintf("ERR:resolve failed: %v", err))
+	}
+	if len(ips) == 0 {
+		return writeResult("ERR:no addresses returned")
+	}
+	parts := make([]string, len(ips))
+	for i, ip := range ips {
+		parts[i] = ip.String()
+	}
+	return writeResult(fmt.Sprintf("OK:%s", strings.Join(parts, ",")))
+}
+
+// testResolveNonexistent attempts to resolve a hostname that does not
+// exist and returns the error message.
+//
+//go:wasmexport test-resolve-nonexistent
+func testResolveNonexistent() uint64 {
+	resolver := wgdns.DefaultResolver()
+	_, err := resolver.Resolve("nonexistent.invalid")
+	if err == nil {
+		return writeResult("ERR:expected error for nonexistent hostname, got nil")
+	}
+	return writeResult(fmt.Sprintf("OK:%s", err.Error()))
+}
+
+// testResolveIPLiteral verifies that IP literals bypass DNS resolution
+// and are returned directly.
+//
+//go:wasmexport test-resolve-ip-literal
+func testResolveIPLiteral() uint64 {
+	resolver := wgdns.DefaultResolver()
+	ips, err := resolver.Resolve("192.168.1.1")
+	if err != nil {
+		return writeResult(fmt.Sprintf("ERR:resolve failed: %v", err))
+	}
+	if len(ips) != 1 {
+		return writeResult(fmt.Sprintf("ERR:expected 1 address, got %d", len(ips)))
+	}
+	if ips[0].String() != "192.168.1.1" {
+		return writeResult(fmt.Sprintf("ERR:expected 192.168.1.1, got %s", ips[0].String()))
+	}
+	return writeResult("OK:192.168.1.1")
+}
+
+// testDialerDNSErrorWrapping exercises the Dialer with a hostname that
+// fails DNS resolution and verifies proper error wrapping.
+//
+//go:wasmexport test-dialer-dns-error
+func testDialerDNSErrorWrapping() uint64 {
+	dialer := wgnet.DefaultDialer()
+	_, err := dialer.Dial("tcp", "nonexistent.invalid:5432")
+	if err == nil {
+		return writeResult("ERR:expected error, got nil")
+	}
+
+	// Verify *net.OpError wrapping
+	var opErr *net.OpError
+	if !errors.As(err, &opErr) {
+		return writeResult(fmt.Sprintf("ERR:expected *net.OpError, got %T: %v", err, err))
+	}
+	if opErr.Op != "dial" {
+		return writeResult(fmt.Sprintf("ERR:expected Op=dial, got %s", opErr.Op))
+	}
+
+	// Verify inner *wgnet.DNSError
+	var dnsErr *wgnet.DNSError
+	if !errors.As(opErr.Err, &dnsErr) {
+		return writeResult(fmt.Sprintf("ERR:expected inner *DNSError, got %T: %v", opErr.Err, opErr.Err))
+	}
+	if dnsErr.Name != "nonexistent.invalid" {
+		return writeResult(fmt.Sprintf("ERR:DNSError.Name=%q, want nonexistent.invalid", dnsErr.Name))
+	}
+
+	return writeResult("OK:correctly wrapped as *net.OpError{*DNSError}")
+}
+
+// ── Helper: pack result string into uint64 (ptr << 32 | len) ───────
+
+var resultBuf []byte
+
+func writeResult(s string) uint64 {
+	resultBuf = []byte(s)
+	ptr := uint64(uintptr(unsafe.Pointer(&resultBuf[0])))
+	length := uint64(len(resultBuf))
+	return (ptr << 32) | length
+}