first commit

web/controller/server_controller.go

@@ -0,0 +1,256 @@
+package controller
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/disk"
+	"github.com/shirou/gopsutil/host"
+	"github.com/shirou/gopsutil/load"
+	"github.com/shirou/gopsutil/mem"
+	"github.com/shirou/gopsutil/net"
+	"net/http"
+	"runtime"
+	"time"
+	"x-ui/logger"
+)
+
+type ProcessState string
+
+const (
+	Running ProcessState = "running"
+	Stop    ProcessState = "stop"
+	Error   ProcessState = "error"
+)
+
+type Status struct {
+	Cpu float64 `json:"cpu"`
+	Mem struct {
+		Current uint64 `json:"current"`
+		Total   uint64 `json:"total"`
+	} `json:"mem"`
+	Swap struct {
+		Current uint64 `json:"current"`
+		Total   uint64 `json:"total"`
+	} `json:"swap"`
+	Disk struct {
+		Current uint64 `json:"current"`
+		Total   uint64 `json:"total"`
+	} `json:"disk"`
+	Xray struct {
+		State    ProcessState `json:"state"`
+		ErrorMsg string       `json:"errorMsg"`
+		Version  string       `json:"version"`
+	} `json:"xray"`
+	Uptime   uint64    `json:"uptime"`
+	Loads    []float64 `json:"loads"`
+	TcpCount int       `json:"tcpCount"`
+	UdpCount int       `json:"udpCount"`
+	NetIO    struct {
+		Up   uint64 `json:"up"`
+		Down uint64 `json:"down"`
+	} `json:"netIO"`
+	NetTraffic struct {
+		Sent uint64 `json:"sent"`
+		Recv uint64 `json:"recv"`
+	} `json:"netTraffic"`
+}
+
+type Release struct {
+	TagName string `json:"tag_name"`
+}
+
+func stopServerController(a *ServerController) {
+	a.stopTask()
+}
+
+type ServerController struct {
+	BaseController
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	lastStatus        *Status
+	lastRefreshTime   time.Time
+	lastGetStatusTime time.Time
+}
+
+func NewServerController(g *gin.RouterGroup) *ServerController {
+	ctx, cancel := context.WithCancel(context.Background())
+	a := &ServerController{
+		ctx:               ctx,
+		cancel:            cancel,
+		lastGetStatusTime: time.Now(),
+	}
+	a.initRouter(g)
+	go a.runTask()
+	runtime.SetFinalizer(a, stopServerController)
+	return a
+}
+
+func (a *ServerController) initRouter(g *gin.RouterGroup) {
+	g.POST("/server/status", a.status)
+	g.POST("/server/getXrayVersion", a.getXrayVersion)
+}
+
+func (a *ServerController) refreshStatus() {
+	status := &Status{}
+
+	now := time.Now()
+
+	percents, err := cpu.Percent(time.Second*2, false)
+	if err != nil {
+		logger.Warning("get cpu percent failed:", err)
+	} else {
+		status.Cpu = percents[0]
+	}
+
+	upTime, err := host.Uptime()
+	if err != nil {
+		logger.Warning("get uptime failed:", err)
+	} else {
+		status.Uptime = upTime
+	}
+
+	memInfo, err := mem.VirtualMemory()
+	if err != nil {
+		logger.Warning("get virtual memory failed:", err)
+	} else {
+		status.Mem.Current = memInfo.Used
+		status.Mem.Total = memInfo.Total
+	}
+
+	swapInfo, err := mem.SwapMemory()
+	if err != nil {
+		logger.Warning("get swap memory failed:", err)
+	} else {
+		status.Swap.Current = swapInfo.Used
+		status.Swap.Total = swapInfo.Total
+	}
+
+	distInfo, err := disk.Usage("/")
+	if err != nil {
+		logger.Warning("get dist usage failed:", err)
+	} else {
+		status.Disk.Current = distInfo.Used
+		status.Disk.Total = distInfo.Total
+	}
+
+	avgState, err := load.Avg()
+	if err != nil {
+		logger.Warning("get load avg failed:", err)
+	} else {
+		status.Loads = []float64{avgState.Load1, avgState.Load5, avgState.Load15}
+	}
+
+	ioStats, err := net.IOCounters(false)
+	if err != nil {
+		logger.Warning("get io counters failed:", err)
+	} else if len(ioStats) > 0 {
+		ioStat := ioStats[0]
+		status.NetTraffic.Sent = ioStat.BytesSent
+		status.NetTraffic.Recv = ioStat.BytesRecv
+
+		if a.lastStatus != nil {
+			duration := now.Sub(a.lastRefreshTime)
+			seconds := float64(duration) / float64(time.Second)
+			up := uint64(float64(status.NetTraffic.Sent-a.lastStatus.NetTraffic.Sent) / seconds)
+			down := uint64(float64(status.NetTraffic.Recv-a.lastStatus.NetTraffic.Recv) / seconds)
+			status.NetIO.Up = up
+			status.NetIO.Down = down
+		}
+	} else {
+		logger.Warning("can not find io counters")
+	}
+
+	tcpConnStats, err := net.Connections("tcp")
+	if err != nil {
+		logger.Warning("get connections failed:", err)
+	} else {
+		status.TcpCount = len(tcpConnStats)
+	}
+
+	udpConnStats, err := net.Connections("udp")
+	if err != nil {
+		logger.Warning("get connections failed:", err)
+	} else {
+		status.UdpCount = len(udpConnStats)
+	}
+
+	// TODO 临时
+	status.Xray.State = Running
+	status.Xray.ErrorMsg = ""
+	status.Xray.Version = "1.0.0"
+
+	a.lastStatus = status
+	a.lastRefreshTime = now
+}
+
+func (a *ServerController) runTask() {
+	for {
+		select {
+		case <-a.ctx.Done():
+			break
+		default:
+		}
+		now := time.Now()
+		if now.Sub(a.lastGetStatusTime) > time.Minute*3 {
+			time.Sleep(time.Second * 2)
+			continue
+		}
+		a.refreshStatus()
+	}
+}
+
+func (a *ServerController) stopTask() {
+	a.cancel()
+}
+
+func (a *ServerController) status(c *gin.Context) {
+	a.lastGetStatusTime = time.Now()
+
+	jsonMsgObj(c, "", a.lastStatus, nil)
+}
+
+var lastVersions []string
+var lastGetReleaseTime time.Time
+
+func (a *ServerController) getXrayVersion(c *gin.Context) {
+	now := time.Now()
+	if now.Sub(lastGetReleaseTime) <= time.Minute {
+		jsonMsgObj(c, "", lastVersions, nil)
+		return
+	}
+	url := "https://api.github.com/repos/XTLS/Xray-core/releases"
+	resp, err := http.Get(url)
+	if err != nil {
+		jsonMsg(c, "获取版本失败，请稍后尝试", err)
+		return
+	}
+
+	defer resp.Body.Close()
+	buffer := bytes.NewBuffer(make([]byte, 8192))
+	buffer.Reset()
+	_, err = buffer.ReadFrom(resp.Body)
+	if err != nil {
+		jsonMsg(c, "获取版本失败，请稍后尝试", err)
+		return
+	}
+
+	releases := make([]Release, 0)
+	err = json.Unmarshal(buffer.Bytes(), &releases)
+	if err != nil {
+		jsonMsg(c, "获取版本失败，请向作者反馈此问题", err)
+		return
+	}
+	versions := make([]string, 0, len(releases))
+	for _, release := range releases {
+		versions = append(versions, release.TagName)
+	}
+	lastVersions = versions
+	lastGetReleaseTime = time.Now()
+
+	jsonMsgObj(c, "", versions, nil)
+}