[BREAKING] added entrypoint middleware support and config, config schema update

internal/config/config.go

@@ -173,6 +173,7 @@ func (cfg *Config) load() E.Error {
 
 	// errors are non fatal below
 	errs := E.NewBuilder(errMsg)
+	errs.Add(entrypoint.SetMiddlewares(model.Entrypoint.Middlewares))
 	errs.Add(cfg.initNotification(model.Providers.Notification))
 	errs.Add(cfg.initAutoCert(&model.AutoCert))
 	errs.Add(cfg.loadRouteProviders(&model.Providers))

internal/config/types/config.go

@@ -2,19 +2,22 @@ package types
 
 type (
 	Config struct {
-		Providers       Providers      `json:"providers" yaml:",flow"`
 		AutoCert        AutoCertConfig `json:"autocert" yaml:",flow"`
-		ExplicitOnly    bool           `json:"explicit_only" yaml:"explicit_only"`
+		Entrypoint      Entrypoint     `json:"entrypoint" yaml:",flow"`
+		Providers       Providers      `json:"providers" yaml:",flow"`
 		MatchDomains    []string       `json:"match_domains" yaml:"match_domains"`
 		Homepage        HomepageConfig `json:"homepage" yaml:"homepage"`
 		TimeoutShutdown int            `json:"timeout_shutdown" yaml:"timeout_shutdown"`
-		RedirectToHTTPS bool           `json:"redirect_to_https" yaml:"redirect_to_https"`
 	}
 	Providers struct {
 		Files        []string             `json:"include" yaml:"include"`
 		Docker       map[string]string    `json:"docker" yaml:"docker"`
 		Notification []NotificationConfig `json:"notification" yaml:"notification"`
 	}
+	Entrypoint struct {
+		RedirectToHTTPS bool `json:"redirect_to_https" yaml:"redirect_to_https"`
+		Middlewares     []map[string]any
+	}
 	NotificationConfig map[string]any
 )
 
@@ -24,6 +27,8 @@ func DefaultConfig() *Config {
 		Homepage: HomepageConfig{
 			UseDefaultCategories: true,
 		},
-		RedirectToHTTPS: false,
+		Entrypoint: Entrypoint{
+			RedirectToHTTPS: false,
+		},
 	}
 }

internal/entrypoint/entrypoint.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
+	"sync"
 
 	"github.com/yusing/go-proxy/internal/net/http/middleware"
 	"github.com/yusing/go-proxy/internal/net/http/middleware/errorpage"
@@ -14,6 +15,11 @@ import (
 
 var findRouteFunc = findRouteAnyDomain
 
+var (
+	epMiddleware   *middleware.Middleware
+	epMiddlewareMu sync.Mutex
+)
+
 func SetFindRouteDomains(domains []string) {
 	if len(domains) == 0 {
 		findRouteFunc = findRouteAnyDomain
@@ -22,9 +28,25 @@ func SetFindRouteDomains(domains []string) {
 	}
 }
 
+func SetMiddlewares(mws []map[string]any) error {
+	epMiddlewareMu.Lock()
+	defer epMiddlewareMu.Unlock()
+
+	mid, err := middleware.BuildMiddlewareFromChainRaw("entrypoint", mws)
+	if err != nil {
+		return err
+	}
+	epMiddleware = mid
+	return nil
+}
+
 func Handler(w http.ResponseWriter, r *http.Request) {
 	mux, err := findRouteFunc(r.Host)
 	if err == nil {
+		if epMiddleware != nil {
+			epMiddleware.ServeHTTP(mux.ServeHTTP, w, r)
+			return
+		}
 		mux.ServeHTTP(w, r)
 		return
 	}

internal/net/http/middleware/middleware.go

@@ -23,7 +23,7 @@ type (
 
 	BeforeFunc         func(next http.HandlerFunc, w ResponseWriter, r *Request)
 	RewriteFunc        func(req *Request)
-	ModifyResponseFunc func(resp *Response) error
+	ModifyResponseFunc = gphttp.ModifyResponseFunc
 	CloneWithOptFunc   func(opts OptionsRaw) (*Middleware, E.Error)
 
 	OptionsRaw = map[string]any
@@ -114,6 +114,17 @@ func (m *Middleware) ModifyResponse(resp *Response) error {
 	return nil
 }
 
+func (m *Middleware) ServeHTTP(next http.HandlerFunc, w ResponseWriter, r *Request) {
+	if m.modifyResponse != nil {
+		w = gphttp.NewModifyResponseWriter(w, r, m.modifyResponse)
+	}
+	if m.before != nil {
+		m.before(next, w, r)
+	} else {
+		next(w, r)
+	}
+}
+
 // TODO: check conflict or duplicates.
 func createMiddlewares(middlewaresMap map[string]OptionsRaw) ([]*Middleware, E.Error) {
 	middlewares := make([]*Middleware, 0, len(middlewaresMap))

internal/net/http/middleware/middleware_builder.go

@@ -11,13 +11,20 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+var ErrMissingMiddlewareUse = E.New("missing middleware 'use' field")
+
 func BuildMiddlewaresFromComposeFile(filePath string, eb *E.Builder) map[string]*Middleware {
 	fileContent, err := os.ReadFile(filePath)
 	if err != nil {
 		eb.Add(err)
 		return nil
 	}
-	return BuildMiddlewaresFromYAML(path.Base(filePath), fileContent, eb)
+	mids := BuildMiddlewaresFromYAML(path.Base(filePath), fileContent, eb)
+	results := make(map[string]*Middleware, len(mids))
+	for k, v := range mids {
+		results[k+"@file"] = v
+	}
+	return results
 }
 
 func BuildMiddlewaresFromYAML(source string, data []byte, eb *E.Builder) map[string]*Middleware {
@@ -29,37 +36,46 @@ func BuildMiddlewaresFromYAML(source string, data []byte, eb *E.Builder) map[str
 	}
 	middlewares := make(map[string]*Middleware)
 	for name, defs := range rawMap {
-		chainErr := E.NewBuilder("")
-		chain := make([]*Middleware, 0, len(defs))
-		for i, def := range defs {
-			if def["use"] == nil || def["use"] == "" {
-				chainErr.Addf("item %d: missing field 'use'", i)
-				continue
-			}
-			baseName := def["use"].(string)
-			base, err := Get(baseName)
-			if err != nil {
-				chainErr.Add(err.Subjectf("%s[%d]", name, i))
-				continue
-			}
-			delete(def, "use")
-			m, err := base.WithOptionsClone(def)
-			if err != nil {
-				chainErr.Add(err.Subjectf("%s[%d]", name, i))
-				continue
-			}
-			m.name = fmt.Sprintf("%s[%d]", name, i)
-			chain = append(chain, m)
-		}
-		if chainErr.HasError() {
-			eb.Add(chainErr.Error().Subject(source))
+		chain, err := BuildMiddlewareFromChainRaw(name, defs)
+		if err != nil {
+			eb.Add(err.Subject(source))
 		} else {
-			middlewares[name+"@file"] = BuildMiddlewareFromChain(name, chain)
+			middlewares[name] = chain
 		}
 	}
 	return middlewares
 }
 
+func BuildMiddlewareFromChainRaw(name string, defs []map[string]any) (*Middleware, E.Error) {
+	chainErr := E.NewBuilder("")
+	chain := make([]*Middleware, 0, len(defs))
+	for i, def := range defs {
+		if def["use"] == nil || def["use"] == "" {
+			chainErr.Add(ErrMissingMiddlewareUse.Subjectf("%s[%d]", name, i))
+			continue
+		}
+		baseName := def["use"].(string)
+		base, err := Get(baseName)
+		if err != nil {
+			chainErr.Add(err.Subjectf("%s[%d]", name, i))
+			continue
+		}
+		delete(def, "use")
+		m, err := base.WithOptionsClone(def)
+		if err != nil {
+			chainErr.Add(err.Subjectf("%s[%d]", name, i))
+			continue
+		}
+		m.name = fmt.Sprintf("%s[%d]", name, i)
+		chain = append(chain, m)
+	}
+	if chainErr.HasError() {
+		return nil, chainErr.Error()
+	} else {
+		return BuildMiddlewareFromChain(name, chain), nil
+	}
+}
+
 // TODO: check conflict or duplicates.
 func BuildMiddlewareFromChain(name string, chain []*Middleware) *Middleware {
 	m := &Middleware{name: name, children: chain}

internal/net/http/server/server.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"io"
 	"log"
+	"net"
 	"net/http"
 	"time"
 
@@ -57,7 +58,11 @@ func NewServer(opt Options) (s *Server) {
 	}
 
 	if certAvailable && opt.RedirectToHTTPS && opt.HTTPSAddr != "" {
-		httpHandler = redirectToTLSHandler(opt.HTTPSAddr)
+		_, port, err := net.SplitHostPort(opt.HTTPSAddr)
+		if err != nil {
+			panic(err)
+		}
+		httpHandler = redirectToTLSHandler(port)
 	} else {
 		httpHandler = opt.Handler
 	}
@@ -151,7 +156,7 @@ func (s *Server) handleErr(scheme string, err error) {
 func redirectToTLSHandler(port string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		r.URL.Scheme = "https"
-		r.URL.Host = r.URL.Hostname() + port
+		r.URL.Host = r.URL.Hostname() + ":" + port
 
 		var redirectCode int
 		if r.Method == http.MethodGet {