25w20a

main.go

@@ -1,10 +1,10 @@
 package main
 
 import (
+	"context"
 	"embed"
 	"flag"
 	"fmt"
-	"io"
 	"io/fs"
 	"net/http"
 	"time"
@@ -13,32 +13,41 @@ import (
 	"ghproxy/auth"
 	"ghproxy/config"
 	"ghproxy/middleware/loggin"
-	"ghproxy/middleware/timing"
 	"ghproxy/proxy"
 	"ghproxy/rate"
 
 	"github.com/WJQSERVER-STUDIO/go-utils/logger"
 
-	"github.com/gin-gonic/gin"
+	"github.com/cloudwego/hertz/pkg/app"
+	"github.com/cloudwego/hertz/pkg/app/middlewares/server/recovery"
+	"github.com/cloudwego/hertz/pkg/app/server"
+	"github.com/cloudwego/hertz/pkg/common/adaptor"
+
+	"github.com/hertz-contrib/http2/factory"
 )
 
 var (
 	cfg        *config.Config
-	router     *gin.Engine
+	r          *server.Hertz
 	configfile = "/data/ghproxy/config/config.toml"
 	cfgfile    string
 	version    string
-	dev        string
 	runMode    string
 	limiter    *rate.RateLimiter
 	iplimiter  *rate.IPRateLimiter
 )
 
 var (
-	//go:embed pages/bootstrap/*
+	//go:embed pages/*
 	pagesFS embed.FS
-	//go:embed pages/nebula/*
-	NebulaPagesFS embed.FS
+	/*
+		//go:embed pages/bootstrap/*
+		BootstrapPagesFS embed.FS
+		//go:embed pages/nebula/*
+		NebulaPagesFS embed.FS
+		//go:embed pages/design/*
+		DesignPagesFS embed.FS
+	*/
 )
 
 var (
@@ -86,8 +95,8 @@ func loadlist(cfg *config.Config) {
 	auth.Init(cfg)
 }
 
-func setupApi(cfg *config.Config, router *gin.Engine, version string) {
-	api.InitHandleRouter(cfg, router, version)
+func setupApi(cfg *config.Config, r *server.Hertz, version string) {
+	api.InitHandleRouter(cfg, r, version)
 }
 
 func setupRateLimit(cfg *config.Config) {
@@ -110,12 +119,17 @@ func InitReq(cfg *config.Config) {
 func loadEmbeddedPages(cfg *config.Config) (fs.FS, error) {
 	var pages fs.FS
 	var err error
-
 	switch cfg.Pages.Theme {
 	case "bootstrap":
 		pages, err = fs.Sub(pagesFS, "pages/bootstrap")
 	case "nebula":
-		pages, err = fs.Sub(NebulaPagesFS, "pages/nebula")
+		pages, err = fs.Sub(pagesFS, "pages/nebula")
+	case "design":
+		pages, err = fs.Sub(pagesFS, "pages/design")
+	case "metro":
+		pages, err = fs.Sub(pagesFS, "pages/metro")
+	case "classic":
+		pages, err = fs.Sub(pagesFS, "pages/classic")
 	default:
 		pages, err = fs.Sub(pagesFS, "pages/bootstrap") // 默认主题
 		logWarning("Invalid Pages Theme: %s, using default theme 'bootstrap'", cfg.Pages.Theme)
@@ -128,7 +142,7 @@ func loadEmbeddedPages(cfg *config.Config) (fs.FS, error) {
 }
 
 // setupPages 设置页面路由
-func setupPages(cfg *config.Config, router *gin.Engine) {
+func setupPages(cfg *config.Config, r *server.Hertz) {
 	switch cfg.Pages.Mode {
 	case "internal":
 		// 加载嵌入式资源
@@ -139,11 +153,42 @@ func setupPages(cfg *config.Config, router *gin.Engine) {
 		}
 
 		// 设置嵌入式资源路由
-		router.GET("/", gin.WrapH(http.FileServer(http.FS(pages))))
-		router.GET("/favicon.ico", gin.WrapH(http.FileServer(http.FS(pages))))
-		router.GET("/script.js", gin.WrapH(http.FileServer(http.FS(pages))))
-		router.GET("/style.css", gin.WrapH(http.FileServer(http.FS(pages))))
-		//router.GET("/bootstrap.min.css", gin.WrapH(http.FileServer(http.FS(pages))))
+		r.GET("/", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
+		r.GET("/favicon.ico", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
+		r.GET("/script.js", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
+		r.GET("/style.css", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
 
 	case "external":
 		// 设置外部资源路径
@@ -154,13 +199,10 @@ func setupPages(cfg *config.Config, router *gin.Engine) {
 		//bootstrapPath := fmt.Sprintf("%s/bootstrap.min.css", cfg.Pages.StaticDir)
 
 		// 设置外部资源路由
-		router.GET("/", func(c *gin.Context) {
-			c.File(indexPagePath)
-			logInfo("IP:%s UA:%s METHOD:%s HTTPv:%s", c.ClientIP(), c.Request.UserAgent(), c.Request.Method, c.Request.Proto)
-		})
-		router.StaticFile("/favicon.ico", faviconPath)
-		router.StaticFile("/script.js", javascriptsPath)
-		router.StaticFile("/style.css", stylesheetsPath)
+		r.StaticFile("/", indexPagePath)
+		r.StaticFile("/favicon.ico", faviconPath)
+		r.StaticFile("/script.js", javascriptsPath)
+		r.StaticFile("/style.css", stylesheetsPath)
 		//router.StaticFile("/bootstrap.min.css", bootstrapPath)
 
 	default:
@@ -174,10 +216,42 @@ func setupPages(cfg *config.Config, router *gin.Engine) {
 			return
 		}
 		// 设置嵌入式资源路由
-		router.GET("/", gin.WrapH(http.FileServer(http.FS(pages))))
-		router.GET("/favicon.ico", gin.WrapH(http.FileServer(http.FS(pages))))
-		router.GET("/script.js", gin.WrapH(http.FileServer(http.FS(pages))))
-		router.GET("/style.css", gin.WrapH(http.FileServer(http.FS(pages))))
+		r.GET("/", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
+		r.GET("/favicon.ico", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
+		r.GET("/script.js", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
+		r.GET("/style.css", func(ctx context.Context, c *app.RequestContext) {
+			staticServer := http.FileServer(http.FS(pages))
+			req, err := adaptor.GetCompatRequest(&c.Request)
+			if err != nil {
+				logError("%s", err)
+				return
+			}
+			staticServer.ServeHTTP(adaptor.GetCompatResponseWriter(&c.Response), req)
+		})
 	}
 }
 
@@ -191,94 +265,87 @@ func init() {
 	setupRateLimit(cfg)
 
 	if cfg.Server.Debug {
-		dev = "true"
-		version = "dev"
-	}
-	if dev == "true" {
-		gin.SetMode(gin.DebugMode)
 		runMode = "dev"
 	} else {
-		gin.SetMode(gin.ReleaseMode)
 		runMode = "release"
 	}
 
-	logDebug("Run Mode: %s", runMode)
-
-	gin.LoggerWithWriter(io.Discard)
-	router = gin.New()
-
-	// 添加recovery中间件
-	router.Use(gin.Recovery())
-
-	// 添加log中间件
-	router.Use(loggin.Middleware())
-
-	// 添加计时中间件
-	router.Use(timing.Middleware())
-
-	if cfg.Server.H2C {
-		router.UseH2C = true
+	if cfg.Server.Debug {
+		version = "Dev"
 	}
 
-	setupApi(cfg, router, version)
+}
 
-	setupPages(cfg, router)
+func main() {
+	logDebug("Run Mode: %s", runMode)
+
+	addr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port)
+
+	r := server.New(
+		server.WithHostPorts(addr),
+		server.WithH2C(true),
+	)
+
+	r.AddProtocol("h2", factory.NewServerFactory())
+
+	// 添加Recovery中间件
+	r.Use(recovery.Recovery())
+	// 添加log中间件
+	r.Use(loggin.Middleware())
+
+	setupApi(cfg, r, version)
+
+	setupPages(cfg, r)
 
 	// 1. GitHub Releases/Archive - Use distinct path segments for type
-	router.GET("/github.com/:username/:repo/releases/*filepath", func(c *gin.Context) { // Distinct path for releases
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/github.com/:username/:repo/releases/*filepath", func(ctx context.Context, c *app.RequestContext) { // Distinct path for releases
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
-	router.GET("/github.com/:username/:repo/archive/*filepath", func(c *gin.Context) { // Distinct path for archive
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/github.com/:username/:repo/archive/*filepath", func(ctx context.Context, c *app.RequestContext) { // Distinct path for archive
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
 	// 2. GitHub Blob/Raw - Use distinct path segments for type
-	router.GET("/github.com/:username/:repo/blob/*filepath", func(c *gin.Context) { // Distinct path for blob
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/github.com/:username/:repo/blob/*filepath", func(ctx context.Context, c *app.RequestContext) { // Distinct path for blob
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
-	router.GET("/github.com/:username/:repo/raw/*filepath", func(c *gin.Context) { // Distinct path for raw
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/github.com/:username/:repo/raw/*filepath", func(ctx context.Context, c *app.RequestContext) { // Distinct path for raw
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
-	router.GET("/github.com/:username/:repo/info/*filepath", func(c *gin.Context) { // Distinct path for info
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/github.com/:username/:repo/info/*filepath", func(ctx context.Context, c *app.RequestContext) { // Distinct path for info
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
-	router.GET("/github.com/:username/:repo/git-upload-pack", func(c *gin.Context) {
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/github.com/:username/:repo/git-upload-pack", func(ctx context.Context, c *app.RequestContext) {
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
 	// 4. Raw GitHubusercontent - Keep as is (assuming it's distinct enough)
-	router.GET("/raw.githubusercontent.com/:username/:repo/*filepath", func(c *gin.Context) {
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/raw.githubusercontent.com/:username/:repo/*filepath", func(ctx context.Context, c *app.RequestContext) {
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
 	// 5. Gist GitHubusercontent - Keep as is (assuming it's distinct enough)
-	router.GET("/gist.githubusercontent.com/:username/*filepath", func(c *gin.Context) {
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/gist.githubusercontent.com/:username/*filepath", func(ctx context.Context, c *app.RequestContext) {
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
 	// 6. GitHub API Repos - Keep as is (assuming it's distinct enough)
-	router.GET("/api.github.com/repos/:username/:repo/*filepath", func(c *gin.Context) {
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.GET("/api.github.com/repos/:username/:repo/*filepath", func(ctx context.Context, c *app.RequestContext) {
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
-	router.NoRoute(func(c *gin.Context) {
-		logInfo(c.Request.URL.Path)
-		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(c)
+	r.NoRoute(func(ctx context.Context, c *app.RequestContext) {
+		proxy.NoRouteHandler(cfg, limiter, iplimiter, runMode)(ctx, c)
 	})
 
 	fmt.Printf("GHProxy Version: %s\n", version)
 	fmt.Printf("A Go Based High-Performance Github Proxy \n")
 	fmt.Printf("Made by WJQSERVER-STUDIO\n")
-}
 
-func main() {
-	err := router.Run(fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port))
-	if err != nil {
-		logError("Failed to start server: %v\n", err)
-	}
+	r.Spin()
 	defer logger.Close()
 	fmt.Println("Program Exit")
 }