x/wasihttp: add wasihttp package

This commit ports the wasihttp package from the [wasi-http-go](https://github.com/ydnar/wasi-http-go)
repository to here under the `x/wasihttp` directory. The wasihttp package provides a
WASI HTTP server and client implementation using Go net/http package.

The ./x/wasihttp/internal directory is regenerated using `make go-bindings` command
from the wasihttp Makefile. Examples can be found in the `x/wasihttp/examples` directory and
can be run under the ./x/wasihttp working directory.

This new package has its own CHANGELOG.md, README.md, and RELEASE.md files to document
the changes, usage, and release notes.

Signed-off-by: Jiaxiao Zhou <[email protected]>

Author: Mossaka

x/wasihttp/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial import of the WASI HTTP package from the standalone repository
+
+### Changed
+- Package import path is now `go.bytecodealliance.org/x/wasihttp`

x/wasihttp/README.md

@@ -0,0 +1,46 @@
+# `go.bytecodealliance.org/x/wasihttp`
+
+Package `go.bytecodealliance.org/x/wasihttp` implements [`wasi:http/proxy`](https://github.com/WebAssembly/wasi-http/blob/v0.2.0/proxy.md) for Go using standard [`net/http`](https://pkg.go.dev/net/http) interfaces.
+
+This package allows Go applications to use the familiar `net/http` API when building WebAssembly modules that use the WASI HTTP standard.
+
+## Prerequisites
+
+To use this package, you'll need:
+
+- [TinyGo](https://tinygo.org/) 0.34.0 or later.
+- [Wasmtime](https://wasmtime.dev/) 26.0.0 or later.
+
+## Usage
+
+### Server
+
+Create a standard Go HTTP server using the familiar `net/http` API:
+
+```go
+package main
+
+import (
+    "net/http"
+    _ "go.bytecodealliance.org/x/wasihttp" // enable wasi-http
+)
+
+func init() {
+    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+        w.Header().Add("X-Go", "Gopher")
+        w.Write([]byte("Hello world!\n"))
+    })
+}
+
+func main() {}
+```
+
+Compile with:
+
+```bash
+tinygo build -target=wasip2-http.json -o server.wasm ./main.go
+```
+
+## Examples
+
+For more examples, see the `examples` directory.

x/wasihttp/RELEASE.md

@@ -0,0 +1,21 @@
+# Release Process
+
+This document describes how to release a new version of the `wasihttp` package.
+
+## Release Steps
+
+1. Update the [CHANGELOG.md](CHANGELOG.md) with the changes since the last release.
+2. Ensure all tests pass and examples work correctly.
+
+## Creating a Release
+
+Create a new git tag for the release:
+
+```bash
+git tag x/wasihttp/v0.1.0
+git push origin x/wasihttp/v0.1.0
+```
+
+## Version Numbering
+
+The `wasihttp` package follows [semantic versioning](https://semver.org/).

x/wasihttp/docs.go

@@ -0,0 +1,11 @@
+// Package wasihttp implements [`wasi:http/proxy`](https://github.com/WebAssembly/wasi-http/blob/v0.2.0/proxy.md) for Go using standard [`net/http`](https://pkg.go.dev/net/http) interfaces
+//
+// It provides an implementation of the wasi:http/proxy interface that allows Go applications
+// to use the standard net/http library for both client and server operations within a WebAssembly
+// module. This allows Go developers to use familiar HTTP APIs when building WebAssembly modules
+// that need to make or handle HTTP requests.
+//
+// To use this package in your Go application, simply import it:
+//
+//	import _ "go.bytecodealliance.org/x/wasihttp"
+package wasihttp

x/wasihttp/examples/basic/basic.go

@@ -0,0 +1,27 @@
+// This example implements a basic web server.
+//
+// To run: `tinygo run -target=wasip2-http.json ./examples/basic`
+// Test /: `curl -v 'http://0.0.0.0:8080/'`
+// Test /error: `curl -v 'http://0.0.0.0:8080/error'`
+
+package main
+
+import (
+	"net/http"
+
+	_ "go.bytecodealliance.org/x/wasihttp"
+)
+
+func init() {
+	// TODO: use "GET /" when TinyGo supports net/http from Go 1.22+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Add("X-Go", "Gopher")
+		w.Write([]byte("Hello world!\n"))
+	})
+
+	http.HandleFunc("/error", func(w http.ResponseWriter, r *http.Request) {
+		// do nothing, force default response handling
+	})
+}
+
+func main() {}

x/wasihttp/examples/counter/counter.go

@@ -0,0 +1,33 @@
+// This example implements a web server with a counter running in a goroutine.
+// This demonstrates instance reuse by the host.
+//
+// To run: `tinygo run -target=wasip2-http.json ./examples/counter`
+// Test /: `curl -v 'http://0.0.0.0:8080/'`
+
+package main
+
+import (
+	"fmt"
+	"net/http"
+
+	_ "go.bytecodealliance.org/x/wasihttp"
+)
+
+func init() {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		n := <-c
+		fmt.Fprintf(w, "%d", n)
+	})
+
+	go func() {
+		var n int
+		for {
+			c <- n
+			n++
+		}
+	}()
+}
+
+var c = make(chan int, 1)
+
+func main() {}

x/wasihttp/examples/proxy/proxy.go

@@ -0,0 +1,59 @@
+// This example implements a reverse proxy that sends requests to postman-echo.com.
+//
+// To run: `tinygo run -target=wasip2-http.json ./examples/proxy`
+// Test GET: `curl -v 'http://0.0.0.0:8080/get'`
+// Test POST: `curl -v -d hello 'http://0.0.0.0:8080/post'`
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"time"
+
+	_ "go.bytecodealliance.org/x/wasihttp"
+)
+
+func init() {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+
+		ctx, cancel := context.WithCancel(r.Context())
+		defer cancel()
+
+		r2 := r.Clone(ctx)
+		r2.Host = "postman-echo.com"
+		r2.URL.Host = "postman-echo.com"
+		r2.URL.Scheme = "https"
+
+		defer func() {
+			dur := time.Since(start)
+			log.Printf("proxied %s in %s\n", r2.URL.String(), dur.String())
+		}()
+
+		res, err := http.DefaultClient.Do(r2)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprintf(w, "error: %v", err)
+			log.Printf("error: %v", err)
+			return
+		}
+
+		for k, v := range res.Header {
+			for _, vv := range v {
+				w.Header().Add(k, vv)
+			}
+		}
+
+		w.WriteHeader(res.StatusCode)
+		if res.Body != nil {
+			io.Copy(w, res.Body)
+			res.Body.Close()
+		}
+	})
+}
+
+func main() {}

x/wasihttp/examples/roundtrip/roundtrip.go

@@ -0,0 +1,80 @@
+// This example is taken from https://github.com/dev-wasm/dev-wasm-go/blob/main/http/main.go
+// demonstrates how to use the wasihttp package to make HTTP requests using the `http.Client` interface.
+//
+// To run: `tinygo build -target=wasip2-roundtrip.json -o roundtrip.wasm ./examples/roundtrip`
+// Test: `wasmtime run -Shttp -Sinherit-network -Sinherit-env roundtrip.wasm`
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+
+	wasihttp "go.bytecodealliance.org/x/wasihttp"
+)
+
+func printResponse(r *http.Response) error {
+	fmt.Printf("Status: %d\n", r.StatusCode)
+	for k, v := range r.Header {
+		fmt.Printf("%s: %s\n", k, v[0])
+	}
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Body: \n%s\n", body)
+	return nil
+}
+
+func main() {
+	client := &http.Client{
+		Transport: &wasihttp.Transport{},
+	}
+	req, err := http.NewRequest("GET", "https://postman-echo.com/get", nil)
+	if err != nil {
+		panic(err.Error())
+	}
+	if req == nil {
+		panic("Nil request!")
+	}
+	res, err := client.Do(req)
+	if err != nil {
+		panic(err.Error())
+	}
+	defer res.Body.Close()
+
+	err = printResponse(res)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	res, err = client.Post("https://postman-echo.com/post", "application/json", bytes.NewReader([]byte("{\"foo\": \"bar\"}")))
+	if err != nil {
+		panic(err.Error())
+	}
+	defer res.Body.Close()
+
+	err = printResponse(res)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	req, err = http.NewRequest("PUT", "http://postman-echo.com/put", bytes.NewReader([]byte("{\"baz\": \"blah\"}")))
+	if err != nil {
+		panic(err.Error())
+	}
+	if req == nil {
+		panic("Nil request!")
+	}
+	res, err = client.Do(req)
+	if err != nil {
+		panic(err.Error())
+	}
+	defer res.Body.Close()
+
+	err = printResponse(res)
+	if err != nil {
+		panic(err.Error())
+	}
+}

x/wasihttp/internal/go/http/proxy/proxy.wit.go

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.