Feat: Add api proxy dev server (#180)

Author: anhoffa

cmd/curio/rpc/rpc.go

@@ -296,7 +296,7 @@ func ListenAndServe(ctx context.Context, dependencies *deps.Deps, shutdownChan c
 	eg.Go(srv.ListenAndServe)
 
 	if dependencies.Cfg.Subsystems.EnableWebGui {
-		web, err := web.GetSrv(ctx, dependencies)
+		web, err := web.GetSrv(ctx, dependencies, false)
 		if err != nil {
 			return err
 		}

go.mod

@@ -37,6 +37,7 @@ require (
 	github.com/google/go-cmp v0.6.0
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/mux v1.8.1
+	github.com/gorilla/websocket v1.5.3
 	github.com/hashicorp/go-multierror v1.1.1
 	github.com/hashicorp/golang-lru/v2 v2.0.7
 	github.com/icza/backscanner v0.0.0-20210726202459-ac2ffc679f94
@@ -158,7 +159,6 @@ require (
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/gopacket v1.1.19 // indirect
 	github.com/google/pprof v0.0.0-20240509144519-723abb6459b7 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hako/durafmt v0.0.0-20200710122514-c0fb7b4da026 // indirect
 	github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect

web/devsrv/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/filecoin-project/curio/deps"
+	"github.com/filecoin-project/curio/deps/config"
+	"github.com/filecoin-project/curio/web"
+)
+
+func main() {
+	srv, err := web.GetSrv(context.Background(),
+		&deps.Deps{
+			Cfg: &config.CurioConfig{
+				Subsystems: config.CurioSubsystemsConfig{GuiAddress: ":4701"},
+			}},
+		true)
+
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println("Running on: ", srv.Addr)
+	if err := srv.ListenAndServe(); err != nil {
+		panic(err)
+	}
+}

web/srv.go

@@ -8,15 +8,18 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
-	"log"
 	"net"
 	"net/http"
+	"net/http/httputil"
+	"net/url"
 	"os"
 	"path"
 	"strings"
 	"time"
 
 	"github.com/gorilla/mux"
+	"github.com/gorilla/websocket"
+	logging "github.com/ipfs/go-log/v2"
 	"go.opencensus.io/tag"
 
 	"github.com/filecoin-project/curio/deps"
@@ -25,35 +28,37 @@ import (
 	"github.com/filecoin-project/lotus/metrics"
 )
 
+var log = logging.Logger("web")
+
 //go:embed static
 var static embed.FS
 
 var basePath = "/static/"
 
-// An dev mode hack for no-restart changes to static and templates.
-// You still need to recomplie the binary for changes to go code.
+// A dev mode hack for no-restart changes to static and templates.
+// You still need to recompile the binary for changes to go code.
 var webDev = os.Getenv("CURIO_WEB_DEV") == "1"
 
-func GetSrv(ctx context.Context, deps *deps.Deps) (*http.Server, error) {
+func GetSrv(ctx context.Context, deps *deps.Deps, devMode bool) (*http.Server, error) {
 	mx := mux.NewRouter()
-	api.Routes(mx.PathPrefix("/api").Subrouter(), deps, webDev)
+	if !devMode {
+		api.Routes(mx.PathPrefix("/api").Subrouter(), deps, webDev)
+	} else {
+		if err := setupDevModeProxy(mx); err != nil {
+			return nil, fmt.Errorf("failed to setup dev mode proxy: %v", err)
+		}
+	}
 
 	var static fs.FS = static
-	if webDev {
+	if webDev || devMode {
 		basePath = ""
 		static = os.DirFS("web/static")
 		mx.Use(func(next http.Handler) http.Handler {
 			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				// Log the request
-				log.Printf("Rcv request: %s %s", r.Method, r.URL.Path)
-
+				log.Debugf("Rcv request: %s %s", r.Method, r.URL.Path)
 				x := &interceptResponseWriter{ResponseWriter: w}
-
-				// Call the next handler
 				next.ServeHTTP(x, r)
-
-				// Log the response
-				log.Printf("HTTP %s %s returned %d bytes with status code %d", r.Method, r.URL.Path, x.Length(), x.StatusCode())
+				log.Debugf("HTTP %s %s returned %d bytes with status code %d", r.Method, r.URL.Path, x.Length(), x.StatusCode())
 			})
 		})
 	}
@@ -131,3 +136,139 @@ func (w *interceptResponseWriter) Length() int {
 func (w *interceptResponseWriter) StatusCode() int {
 	return w.status
 }
+
+func setupDevModeProxy(mx *mux.Router) error {
+	log.Debugf("Setting up dev mode proxy")
+	apiSrv := os.Getenv("CURIO_API_SRV")
+	if apiSrv == "" {
+		return fmt.Errorf("CURIO_API_SRV environment variable is not set")
+	}
+
+	apiURL, err := url.Parse(apiSrv)
+	if err != nil {
+		return fmt.Errorf("invalid CURIO_API_SRV URL: %v", err)
+	}
+	log.Debugf("Parsed API URL: %s", apiURL.String())
+
+	proxy := createReverseProxy(apiURL)
+
+	mx.PathPrefix("/api").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Debugf("Received request: %s %s", r.Method, r.URL.Path)
+		if websocket.IsWebSocketUpgrade(r) {
+			websocketProxy(apiURL, w, r)
+		} else {
+			proxy.ServeHTTP(w, r)
+		}
+	})
+
+	log.Infof("Dev mode proxy setup complete")
+	return nil
+}
+
+func createReverseProxy(target *url.URL) *httputil.ReverseProxy {
+	log.Debugf("Creating reverse proxy")
+	proxy := httputil.NewSingleHostReverseProxy(target)
+
+	originalDirector := proxy.Director
+	proxy.Director = func(req *http.Request) {
+		log.Debugf("Directing request: %s %s", req.Method, req.URL.Path)
+		originalDirector(req)
+		req.URL.Path = path.Join(target.Path, req.URL.Path)
+
+		if !strings.HasPrefix(req.URL.Path, "/") {
+			req.URL.Path = "/" + req.URL.Path
+		}
+
+		req.URL.Scheme = target.Scheme
+		req.URL.Host = target.Host
+	}
+
+	proxy.ModifyResponse = func(resp *http.Response) error {
+		log.Debugf("Modifying response: %d %s", resp.StatusCode, resp.Status)
+		resp.Header.Del("Connection")
+		resp.Header.Del("Upgrade")
+		return nil
+	}
+
+	proxy.Transport = &http.Transport{
+		Proxy: http.ProxyFromEnvironment,
+		DialContext: (&net.Dialer{
+			Timeout:   30 * time.Second,
+			KeepAlive: 30 * time.Second,
+		}).DialContext,
+		ForceAttemptHTTP2:     true,
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+	}
+
+	log.Infof("Reverse proxy created")
+	return proxy
+}
+
+func websocketProxy(target *url.URL, w http.ResponseWriter, r *http.Request) {
+	log.Debugf("Starting WebSocket proxy")
+	d := websocket.Dialer{
+		Proxy:            http.ProxyFromEnvironment,
+		HandshakeTimeout: 45 * time.Second,
+	}
+
+	// Preserve the original path and query
+	wsTarget := *target
+	wsTarget.Scheme = "ws"
+	wsTarget.Path = path.Join(wsTarget.Path, r.URL.Path)
+
+	if !strings.HasPrefix(wsTarget.Path, "/") {
+		wsTarget.Path = "/" + wsTarget.Path
+	}
+
+	wsTarget.RawQuery = r.URL.RawQuery
+	backendConn, resp, err := d.Dial(wsTarget.String(), nil)
+	if err != nil {
+		log.Errorf("Failed to connect to backend: %v", err)
+		if resp != nil {
+			log.Debugf("Backend response: %d %s", resp.StatusCode, resp.Status)
+		}
+		http.Error(w, "Failed to connect to backend", http.StatusServiceUnavailable)
+		return
+	}
+	defer backendConn.Close()
+
+	upgrader := websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool {
+			return true // Implement a more secure check in production
+		},
+	}
+	clientConn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Errorf("Failed to upgrade connection: %v", err)
+		http.Error(w, "Failed to upgrade connection", http.StatusInternalServerError)
+		return
+	}
+	defer clientConn.Close()
+
+	errc := make(chan error, 2)
+	go proxyCopy(clientConn, backendConn, errc, "client -> backend")
+	go proxyCopy(backendConn, clientConn, errc, "backend -> client")
+
+	err = <-errc
+	log.Debugf("WebSocket proxy ended: %v", err)
+}
+
+func proxyCopy(dst, src *websocket.Conn, errc chan<- error, direction string) {
+	for {
+		messageType, p, err := src.ReadMessage()
+		if err != nil {
+			log.Errorf("Error reading message (%s): %v", direction, err)
+			errc <- err
+			return
+		}
+		log.Debugf("Proxying message (%s): type %d, size %d bytes", direction, messageType, len(p))
+		if err := dst.WriteMessage(messageType, p); err != nil {
+			log.Errorf("Error writing message (%s): %v", direction, err)
+			errc <- err
+			return
+		}
+	}
+}