v0.5.0-rc5: check release

src/route/http_route.go

@@ -2,8 +2,8 @@ package route
 
 import (
 	"crypto/tls"
-	"fmt"
 	"net"
+	"sync"
 	"time"
 
 	"net/http"
@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/sirupsen/logrus"
+	"github.com/yusing/go-proxy/docker/idlewatcher"
 	E "github.com/yusing/go-proxy/error"
 	P "github.com/yusing/go-proxy/proxy"
 	PT "github.com/yusing/go-proxy/proxy/fields"
@@ -23,57 +24,65 @@ type (
 		TargetURL    *URL            `json:"target_url"`
 		PathPatterns PT.PathPatterns `json:"path_patterns"`
 
+		entry   *P.ReverseProxyEntry
 		mux     *http.ServeMux
 		handler *P.ReverseProxy
+
+		regIdleWatcher   func() E.NestedError
+		unregIdleWatcher func()
 	}
 
 	URL          url.URL
-	PathKey      = PT.PathPattern
 	SubdomainKey = PT.Alias
 )
 
-var httpRoutes = F.NewMap[SubdomainKey, *HTTPRoute]()
+func NewHTTPRoute(entry *P.ReverseProxyEntry) (*HTTPRoute, E.NestedError) {
+	var trans http.RoundTripper
+	var regIdleWatcher func() E.NestedError
+	var unregIdleWatcher func()
 
-func NewHTTPRoute(entry *P.Entry) (*HTTPRoute, E.NestedError) {
-	var tr *http.Transport
 	if entry.NoTLSVerify {
-		tr = transportNoTLS
+		trans = transportNoTLS
 	} else {
-		tr = transport
+		trans = transport
 	}
 
-	rp := P.NewReverseProxy(entry.URL, tr, entry)
+	rp := P.NewReverseProxy(entry.URL, trans, entry)
 
-	httpRoutes.Lock()
-	defer httpRoutes.Unlock()
-
-	var r *HTTPRoute
-	r, ok := httpRoutes.UnsafeGet(entry.Alias)
-	if !ok {
-		r = &HTTPRoute{
-			Alias:        entry.Alias,
-			TargetURL:    (*URL)(entry.URL),
-			PathPatterns: entry.PathPatterns,
-			handler:      rp,
+	if entry.UseIdleWatcher() {
+		regIdleWatcher = func() E.NestedError {
+			watcher, err := idlewatcher.Register(entry)
+			if err.HasError() {
+				return err
+			}
+			// patch round-tripper
+			rp.Transport = watcher.PatchRoundTripper(trans)
+			return nil
 		}
-		httpRoutes.UnsafeSet(entry.Alias, r)
-	}
-
-	rewrite := rp.Rewrite
-
-	if logrus.GetLevel() == logrus.DebugLevel {
-		l := logrus.WithField("alias", entry.Alias)
-
-		rp.Rewrite = func(pr *P.ProxyRequest) {
-			l.Debug("request URL: ", pr.In.Host, pr.In.URL.Path)
-			l.Debug("request headers: ", pr.In.Header)
-			rewrite(pr)
+		unregIdleWatcher = func() {
+			idlewatcher.Unregister(entry.ContainerName)
+			rp.Transport = trans
 		}
-	} else {
-		rp.Rewrite = rewrite
 	}
 
-	return r, E.Nil()
+	httpRoutesMu.Lock()
+	defer httpRoutesMu.Unlock()
+
+	_, exists := httpRoutes.Load(entry.Alias)
+	if exists {
+		return nil, E.AlreadyExist("HTTPRoute alias", entry.Alias)
+	}
+
+	r := &HTTPRoute{
+		Alias:            entry.Alias,
+		TargetURL:        (*URL)(entry.URL),
+		PathPatterns:     entry.PathPatterns,
+		entry:            entry,
+		handler:          rp,
+		regIdleWatcher:   regIdleWatcher,
+		unregIdleWatcher: unregIdleWatcher,
+	}
+	return r, nil
 }
 
 func (r *HTTPRoute) String() string {
@@ -81,18 +90,35 @@ func (r *HTTPRoute) String() string {
 }
 
 func (r *HTTPRoute) Start() E.NestedError {
+	httpRoutesMu.Lock()
+	defer httpRoutesMu.Unlock()
+
+	if r.regIdleWatcher != nil {
+		if err := r.regIdleWatcher(); err.HasError() {
+			return err
+		}
+	}
+
 	r.mux = http.NewServeMux()
 	for _, p := range r.PathPatterns {
 		r.mux.HandleFunc(string(p), r.handler.ServeHTTP)
 	}
-	httpRoutes.Set(r.Alias, r)
-	return E.Nil()
+
+	httpRoutes.Store(r.Alias, r)
+	return nil
 }
 
 func (r *HTTPRoute) Stop() E.NestedError {
+	httpRoutesMu.Lock()
+	defer httpRoutesMu.Unlock()
+
+	if r.unregIdleWatcher != nil {
+		r.unregIdleWatcher()
+	}
+
 	r.mux = nil
 	httpRoutes.Delete(r.Alias)
-	return E.Nil()
+	return nil
 }
 
 func (u *URL) String() string {
@@ -104,27 +130,26 @@ func (u *URL) MarshalText() (text []byte, err error) {
 }
 
 func ProxyHandler(w http.ResponseWriter, r *http.Request) {
-	mux, err := findMux(r.Host, PathKey(r.URL.Path))
+	mux, err := findMux(r.Host)
 	if err != nil {
 		err = E.Failure("request").
 			Subjectf("%s %s%s", r.Method, r.Host, r.URL.Path).
 			With(err)
-		http.Error(w, err.Error(), http.StatusNotFound)
+		http.Error(w, err.String(), http.StatusNotFound)
 		logrus.Error(err)
 		return
 	}
 	mux.ServeHTTP(w, r)
 }
 
-func findMux(host string, path PathKey) (*http.ServeMux, error) {
+func findMux(host string) (*http.ServeMux, E.NestedError) {
 	sd := strings.Split(host, ".")[0]
-	if r, ok := httpRoutes.UnsafeGet(PT.Alias(sd)); ok {
+	if r, ok := httpRoutes.Load(PT.Alias(sd)); ok {
 		return r.mux, nil
 	}
-	return nil, E.NotExists("route", fmt.Sprintf("subdomain: %s, path: %s", sd, path))
+	return nil, E.NotExist("route", sd)
 }
 
-// TODO: default + per proxy
 var (
 	transport = &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
@@ -135,10 +160,12 @@ var (
 		MaxIdleConns:        1000,
 		MaxIdleConnsPerHost: 1000,
 	}
-
 	transportNoTLS = func() *http.Transport {
 		var clone = transport.Clone()
 		clone.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
 		return clone
 	}()
+
+	httpRoutes   = F.NewMapOf[SubdomainKey, *HTTPRoute]()
+	httpRoutesMu sync.Mutex
 )