gohttp/admin/admin.go

package admin

import (
	"errors"
	"net/http"
	"runtime"

	"git.kingecg.top/kingecg/gohttpd/handler"
	"git.kingecg.top/kingecg/gohttpd/model"
	"git.kingecg.top/kingecg/gohttpd/server"
	"github.com/gin-gonic/gin" // 添加Gin框架导入
)

type RunStatus struct {
	Goroutines int `json:"goroutines"`
}

func about(c *gin.Context) {
	c.Writer.WriteHeader(http.StatusOK)
	c.Writer.Write([]byte("About Page"))

}

func setConfig(c *gin.Context) {
	ctx := c.Request.Context()
	ctxData := ctx.Value(server.RequestCtxKey("data")).(map[string]interface{})
	data, ok := ctxData["data"]
	if !ok {
		c.Writer.WriteHeader(http.StatusBadRequest)
		return
	}
	t, ok := data.(model.HttpServerConfig)
	if ok {
		if t.Name == "admin" {
			c.Writer.WriteHeader(http.StatusForbidden)
			resp := server.NewErrorResult(errors.New("不能通过api设置管理服务器"))
			c.Writer.Write(resp)
			return
		}
		er := model.SetServerConfig(&t)
		if er != nil {
			c.Writer.WriteHeader(http.StatusBadRequest)
			c.Writer.Write(server.NewErrorResult(er))
			return
		}
	} else {
		tcpProxy, ok := data.(model.TcpProxyConfig)
		if ok {
			er := model.SetTcpProxyConfig(&tcpProxy)
			if er != nil {
				c.Writer.WriteHeader(http.StatusBadRequest)
				c.Writer.Write(server.NewErrorResult(er))
				return
			}
		}
	}

	c.Writer.WriteHeader(http.StatusOK)
	c.Writer.Write(server.NewSuccessResult(t))
}

func getServerConfigure(c *gin.Context) {
	// ctx := c.Request.Context()
	// get url param
	// g.
	//ctxData := ctx.Value(server.RequestCtxKey("data")).(map[string]interface{})
	id := c.Param("name")
	if id != "" {
		if id == "admin" {
			c.Writer.WriteHeader(http.StatusForbidden)
			resp := server.NewErrorResult(errors.New("不能通过api获取管理服务器配置信息"))
			c.Writer.Write(resp)
			return
		}
		data := model.GetServerConfig(id)
		c.Writer.WriteHeader(http.StatusOK)
		c.Writer.Write(server.NewSuccessResult(data))
	} else {
		http.NotFound(c.Writer, c.Request)
	}
}
func listConfig(c *gin.Context) {
	data := model.GetConfig().Servers
	// c.JSON(http.StatusOK, server.NewSuccessResult(data))

	c.JSON(http.StatusOK, server.NewResultObj(data))
}

func getStatus(c *gin.Context) {
	runtime := runtime.NumGoroutine()
	ret := RunStatus{
		Goroutines: runtime,
	}
	c.Writer.WriteHeader(http.StatusOK)
	c.Writer.Write(server.NewSuccessResult(ret))
}

func stop(c *gin.Context) {
	// ctx := c.Request.Context()
	// ctxData := ctx.Value(server.RequestCtxKey("data")).(map[string]interface{})
	name := c.Param("name")
	if name != "" {
		serverConf := model.GetServerConfig(name)
		if serverConf == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("server not found")))
			return
		}
		server.StopServer(name, serverConf.Port)
		c.Writer.WriteHeader(http.StatusOK)
		data := "stopped"
		c.Writer.Write(server.NewSuccessResult(data))
		return
	}
	http.NotFound(c.Writer, c.Request)
}

func start(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		serverConf := model.GetServerConfig(name)
		if serverConf == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("server not found")))
			return
		}
		server.StartServer(name, serverConf.Port)
		c.Writer.WriteHeader(http.StatusOK)
		data := "started"
		c.Writer.Write(server.NewSuccessResult(data))
		return
	}
}

func restart(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		serverConf := model.GetServerConfig(name)
		if serverConf == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("server not found")))
			return
		}
		// 先停止再启动
		server.StopServer(name, serverConf.Port)
		server.StartServer(name, serverConf.Port)
		c.Writer.WriteHeader(http.StatusOK)
		data := "restarted"
		c.Writer.Write(server.NewSuccessResult(data))
		return
	}
}

func deleteServer(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		serverConf := model.GetServerConfig(name)
		if serverConf == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("server not found")))
			return
		}
		// 先停止服务器
		server.StopServer(name, serverConf.Port)
		// 从配置中删除
		err := model.DeleteServerConfig(name)
		if err != nil {
			c.Writer.WriteHeader(http.StatusInternalServerError)
			c.Writer.Write(server.NewErrorResult(err))
			return
		}
		c.Writer.WriteHeader(http.StatusOK)
		c.Writer.Write(server.NewSuccessResult("deleted"))
		return
	}
}

// TCP代理相关API

func listTcpProxy(c *gin.Context) {
	data := model.GetConfig().TcpProxys
	c.JSON(http.StatusOK, server.NewResultObj(data))
}

func setTcpProxy(c *gin.Context) {
	ctx := c.Request.Context()
	ctxData := ctx.Value(server.RequestCtxKey("data")).(map[string]interface{})
	data, ok := ctxData["data"]
	if !ok {
		c.Writer.WriteHeader(http.StatusBadRequest)
		return
	}
	tcpProxy, ok := data.(model.TcpProxyConfig)
	if !ok {
		c.Writer.WriteHeader(http.StatusBadRequest)
		c.Writer.Write(server.NewErrorResult(errors.New("invalid tcp proxy config")))
		return
	}
	er := model.SetTcpProxyConfig(&tcpProxy)
	if er != nil {
		c.Writer.WriteHeader(http.StatusBadRequest)
		c.Writer.Write(server.NewErrorResult(er))
		return
	}
	c.Writer.WriteHeader(http.StatusOK)
	c.Writer.Write(server.NewSuccessResult(tcpProxy))
}

func getTcpProxy(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		data := model.GetTcpProxyConfig(name)
		if data == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("tcp proxy not found")))
			return
		}
		c.Writer.WriteHeader(http.StatusOK)
		c.Writer.Write(server.NewSuccessResult(data))
		return
	}
	http.NotFound(c.Writer, c.Request)
}

func deleteTcpProxy(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		tcpProxy := model.GetTcpProxyConfig(name)
		if tcpProxy == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("tcp proxy not found")))
			return
		}
		// 如果正在运行，先停止
		if proxy, ok := server.TcpProxyManager[name]; ok {
			proxy.Stop()
			delete(server.TcpProxyManager, name)
		}
		// 从配置中删除
		err := model.DeleteTcpProxyConfig(name)
		if err != nil {
			c.Writer.WriteHeader(http.StatusInternalServerError)
			c.Writer.Write(server.NewErrorResult(err))
			return
		}
		c.Writer.WriteHeader(http.StatusOK)
		c.Writer.Write(server.NewSuccessResult("deleted"))
		return
	}
	http.NotFound(c.Writer, c.Request)
}

func startTcpProxy(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		tcpProxy := model.GetTcpProxyConfig(name)
		if tcpProxy == nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("tcp proxy not found")))
			return
		}
		if _, ok := server.TcpProxyManager[name]; ok {
			c.Writer.WriteHeader(http.StatusOK)
			c.Writer.Write(server.NewSuccessResult("already started"))
			return
		}
		proxy := handler.NewTcpProxyHandler(tcpProxy.Name, tcpProxy.Listen, tcpProxy.Target)
		server.AddTcpProxy(name, proxy)
		proxy.Start()
		c.Writer.WriteHeader(http.StatusOK)
		c.Writer.Write(server.NewSuccessResult("started"))
		return
	}
	http.NotFound(c.Writer, c.Request)
}

func stopTcpProxy(c *gin.Context) {
	name := c.Param("name")
	if name != "" {
		proxy, ok := server.TcpProxyManager[name]
		if !ok {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.Writer.Write(server.NewErrorResult(errors.New("tcp proxy not found or not running")))
			return
		}
		proxy.Stop()
		delete(server.TcpProxyManager, name)
		c.Writer.WriteHeader(http.StatusOK)
		c.Writer.Write(server.NewSuccessResult("stopped"))
		return
	}
	http.NotFound(c.Writer, c.Request)
}

var AdminServerMux *gin.Engine

// InitAdminApi 初始化管理API路由
// 参数:
//
//	conf: 指向HttpServerConfig的指针，包含服务器配置信息。
//
// 返回值:
//
//	无直接返回值，初始化全局AdminServerMux变量。
func InitAdminApi(conf *model.HttpServerConfig) {
	// 创建Gin路由器实例
	router := gin.Default()

	// 根据认证类型添加中间件
	if conf.AuthType == "jwt" {
		router.Use(jwtAuth) // 使用JWT认证中间件
	} else if conf.AuthType == "basic" {
		router.Use(ginBashiAuth) // 使用基础认证中间件
	}

	// 注册路由处理函数
	api := router.Group("/")
	{
		api.GET("about", about)

		configGroup := api.Group("config")
		{
			configGroup.POST("", setConfig)
			configGroup.GET("", listConfig)
			configGroup.GET(":name", getServerConfigure)
		}

		api.GET("status", getStatus)

		serverGroup := api.Group("server")
		{
			serverGroup.POST("stop/:name", stop)
			serverGroup.POST("start/:name", start)
			serverGroup.POST("restart/:name", restart)
			serverGroup.DELETE(":name", deleteServer)
		}

		// TCP代理路由
		tcpGroup := api.Group("tcp")
		{
			tcpGroup.GET("", listTcpProxy)
			tcpGroup.POST("", setTcpProxy)
			tcpGroup.GET(":name", getTcpProxy)
			tcpGroup.DELETE(":name", deleteTcpProxy)
			tcpGroup.POST("start/:name", startTcpProxy)
			tcpGroup.POST("stop/:name", stopTcpProxy)
		}

		api.POST("login", login)
	}

	// 将路由器赋值给全局变量
	AdminServerMux = router
}