完成xray启动

web/service/config.json

@@ -0,0 +1,64 @@
+{
+  "api": {
+    "services": [
+      "HandlerService",
+      "LoggerService",
+      "StatsService"
+    ],
+    "tag": "api"
+  },
+  "inbounds": [
+    {
+      "listen": "127.0.0.1",
+      "port": 62789,
+      "protocol": "dokodemo-door",
+      "settings": {
+        "address": "127.0.0.1"
+      },
+      "tag": "api"
+    }
+  ],
+  "outbounds": [
+    {
+      "protocol": "freedom",
+      "settings": {}
+    },
+    {
+      "protocol": "blackhole",
+      "settings": {},
+      "tag": "blocked"
+    }
+  ],
+  "policy": {
+    "system": {
+      "statsInboundDownlink": true,
+      "statsInboundUplink": true
+    }
+  },
+  "routing": {
+    "rules": [
+      {
+        "inboundTag": [
+          "api"
+        ],
+        "outboundTag": "api",
+        "type": "field"
+      },
+      {
+        "ip": [
+          "geoip:private"
+        ],
+        "outboundTag": "blocked",
+        "type": "field"
+      },
+      {
+        "outboundTag": "blocked",
+        "protocol": [
+          "bittorrent"
+        ],
+        "type": "field"
+      }
+    ]
+  },
+  "stats": {}
+}

web/service/inbound.go

@@ -0,0 +1,40 @@
+package service
+
+import (
+	"gorm.io/gorm"
+	"x-ui/database"
+	"x-ui/database/model"
+)
+
+type InboundService struct {
+}
+
+func (s *InboundService) GetInbounds(userId int) ([]*model.Inbound, error) {
+	db := database.GetDB()
+	var inbounds []*model.Inbound
+	err := db.Model(model.Inbound{}).Where("user_id = ?", userId).Find(&inbounds).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	return inbounds, nil
+}
+
+func (s *InboundService) GetAllInbounds() ([]*model.Inbound, error) {
+	db := database.GetDB()
+	var inbounds []*model.Inbound
+	err := db.Model(model.Inbound{}).Find(&inbounds).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	return inbounds, nil
+}
+
+func (s *InboundService) AddInbound(inbound *model.Inbound) error {
+	db := database.GetDB()
+	return db.Save(inbound).Error
+}
+
+func (s *InboundService) DelInbound(id int) error {
+	db := database.GetDB()
+	return db.Delete(model.Inbound{}, id).Error
+}

web/service/server.go

@@ -0,0 +1,299 @@
+package service
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"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"
+	"io"
+	"io/fs"
+	"net/http"
+	"os"
+	"runtime"
+	"time"
+	"x-ui/logger"
+	"x-ui/xray"
+)
+
+type ProcessState string
+
+const (
+	Running ProcessState = "running"
+	Stop    ProcessState = "stop"
+	Error   ProcessState = "error"
+)
+
+type Status struct {
+	T   time.Time `json:"-"`
+	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"`
+}
+
+type ServerService struct {
+	xrayService XrayService
+}
+
+func (s *ServerService) GetStatus(lastStatus *Status) *Status {
+	now := time.Now()
+	status := &Status{
+		T: 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 lastStatus != nil {
+			duration := now.Sub(lastStatus.T)
+			seconds := float64(duration) / float64(time.Second)
+			up := uint64(float64(status.NetTraffic.Sent-lastStatus.NetTraffic.Sent) / seconds)
+			down := uint64(float64(status.NetTraffic.Recv-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)
+	}
+
+	if s.xrayService.IsXrayRunning() {
+		status.Xray.State = Running
+		status.Xray.ErrorMsg = ""
+	} else {
+		err := s.xrayService.GetXrayErr()
+		if err != nil {
+			status.Xray.State = Error
+		} else {
+			status.Xray.State = Stop
+		}
+		status.Xray.ErrorMsg = s.xrayService.GetXrayResult()
+	}
+	status.Xray.Version = s.xrayService.GetXrayVersion()
+
+	return status
+}
+
+func (s *ServerService) GetXrayVersions() ([]string, error) {
+	url := "https://api.github.com/repos/XTLS/Xray-core/releases"
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+	buffer := bytes.NewBuffer(make([]byte, 8192))
+	buffer.Reset()
+	_, err = buffer.ReadFrom(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	releases := make([]Release, 0)
+	err = json.Unmarshal(buffer.Bytes(), &releases)
+	if err != nil {
+		return nil, err
+	}
+	versions := make([]string, 0, len(releases))
+	for _, release := range releases {
+		versions = append(versions, release.TagName)
+	}
+	return versions, nil
+}
+
+func (s *ServerService) downloadXRay(version string) (string, error) {
+	osName := runtime.GOOS
+	arch := runtime.GOARCH
+
+	switch osName {
+	case "darwin":
+		osName = "macos"
+	}
+
+	switch arch {
+	case "amd64":
+		arch = "64"
+	case "arm64":
+		arch = "arm64-v8a"
+	}
+
+	fileName := fmt.Sprintf("Xray-%s-%s.zip", osName, arch)
+	url := fmt.Sprintf("https://github.com/XTLS/Xray-core/releases/download/%s/%s", version, fileName)
+	resp, err := http.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	os.Remove(fileName)
+	file, err := os.Create(fileName)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	_, err = io.Copy(file, resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	return fileName, nil
+}
+
+func (s *ServerService) UpdateXray(version string) error {
+	zipFileName, err := s.downloadXRay(version)
+	if err != nil {
+		return err
+	}
+
+	zipFile, err := os.Open(zipFileName)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		zipFile.Close()
+		os.Remove(zipFileName)
+	}()
+
+	stat, err := zipFile.Stat()
+	if err != nil {
+		return err
+	}
+	reader, err := zip.NewReader(zipFile, stat.Size())
+	if err != nil {
+		return err
+	}
+
+	s.xrayService.StopXray()
+	defer s.xrayService.StartXray()
+
+	copyZipFile := func(zipName string, fileName string) error {
+		zipFile, err := reader.Open(zipName)
+		if err != nil {
+			return err
+		}
+		os.Remove(fileName)
+		file, err := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR|os.O_TRUNC, fs.ModePerm)
+		if err != nil {
+			return err
+		}
+		defer file.Close()
+		_, err = io.Copy(file, zipFile)
+		return err
+	}
+
+	err = copyZipFile("xray", xray.GetBinaryPath())
+	if err != nil {
+		return err
+	}
+	err = copyZipFile("geosite.dat", xray.GetGeositePath())
+	if err != nil {
+		return err
+	}
+	err = copyZipFile("geoip.dat", xray.GetGeoipPath())
+	if err != nil {
+		return err
+	}
+
+	return nil
+
+}

web/service/setting.go

@@ -0,0 +1,112 @@
+package service
+
+import (
+	_ "embed"
+	"strconv"
+	"strings"
+	"x-ui/database"
+	"x-ui/database/model"
+	"x-ui/logger"
+	"x-ui/util/random"
+)
+
+//go:embed config.json
+var xrayTemplateConfig string
+
+type SettingService struct {
+}
+
+func (s *SettingService) ClearSetting() error {
+	db := database.GetDB()
+	return db.Delete(model.Setting{}).Error
+}
+
+func (s *SettingService) getSetting(key string) (*model.Setting, error) {
+	db := database.GetDB()
+	setting := &model.Setting{}
+	err := db.Model(model.Setting{}).Where("key = ?", key).First(setting).Error
+	if err != nil {
+		return nil, err
+	}
+	return setting, nil
+}
+
+func (s *SettingService) saveSetting(key string, value string) error {
+	setting, err := s.getSetting(key)
+	db := database.GetDB()
+	if database.IsNotFound(err) {
+		return db.Create(&model.Setting{
+			Key:   key,
+			Value: value,
+		}).Error
+	} else if err != nil {
+		return err
+	}
+	setting.Key = key
+	setting.Value = value
+	return db.Save(setting).Error
+}
+
+func (s *SettingService) getString(key string, defaultValue string) (string, error) {
+	setting, err := s.getSetting(key)
+	if database.IsNotFound(err) {
+		return defaultValue, nil
+	} else if err != nil {
+		return "", err
+	}
+	return setting.Value, nil
+}
+
+func (s *SettingService) getInt(key string, defaultValue int) (int, error) {
+	str, err := s.getString(key, strconv.Itoa(defaultValue))
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(str)
+}
+
+func (s *SettingService) GetXrayConfigTemplate() (string, error) {
+	return s.getString("xray_template_config", xrayTemplateConfig)
+}
+
+func (s *SettingService) GetListen() (string, error) {
+	return s.getString("web_listen", "")
+}
+
+func (s *SettingService) GetPort() (int, error) {
+	return s.getInt("web_port", 65432)
+}
+
+func (s *SettingService) GetCertFile() (string, error) {
+	return s.getString("web_cert_file", "")
+}
+
+func (s *SettingService) GetKeyFile() (string, error) {
+	return s.getString("web_key_file", "")
+}
+
+func (s *SettingService) GetSecret() ([]byte, error) {
+	seq := random.Seq(32)
+	secret, err := s.getString("secret", seq)
+	if secret == seq {
+		err := s.saveSetting("secret", secret)
+		if err != nil {
+			logger.Warning("save secret failed:", err)
+		}
+	}
+	return []byte(secret), err
+}
+
+func (s *SettingService) GetBasePath() (string, error) {
+	basePath, err := s.getString("web_base_path", "/")
+	if err != nil {
+		return "", err
+	}
+	if !strings.HasPrefix(basePath, "/") {
+		basePath = "/" + basePath
+	}
+	if !strings.HasSuffix(basePath, "/") {
+		basePath += "/"
+	}
+	return basePath, nil
+}

web/service/xray.go

@@ -0,0 +1,100 @@
+package service
+
+import (
+	"encoding/json"
+	"errors"
+	"x-ui/util/common"
+	"x-ui/xray"
+)
+
+var p *xray.Process
+var result string
+
+type XrayService struct {
+	inboundService InboundService
+	settingService SettingService
+}
+
+func (s *XrayService) IsXrayRunning() bool {
+	return p != nil && p.IsRunning()
+}
+
+func (s *XrayService) GetXrayErr() error {
+	if p == nil {
+		return nil
+	}
+	return p.GetErr()
+}
+
+func (s *XrayService) GetXrayResult() string {
+	if result != "" {
+		return result
+	}
+	if s.IsXrayRunning() {
+		return ""
+	}
+	if p == nil {
+		return ""
+	}
+	result = p.GetResult()
+	return result
+}
+
+func (s *XrayService) GetXrayVersion() string {
+	if p == nil {
+		return "Unknown"
+	}
+	return p.GetVersion()
+}
+
+func (s *XrayService) GetXrayConfig() (*xray.Config, error) {
+	templateConfig, err := s.settingService.GetXrayConfigTemplate()
+	if err != nil {
+		return nil, err
+	}
+
+	xrayConfig := &xray.Config{}
+	err = json.Unmarshal([]byte(templateConfig), xrayConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	inbounds, err := s.inboundService.GetAllInbounds()
+	if err != nil {
+		return nil, err
+	}
+	for _, inbound := range inbounds {
+		inboundConfig := inbound.GenXrayInboundConfig()
+		xrayConfig.InboundConfigs = append(xrayConfig.InboundConfigs, *inboundConfig)
+	}
+	return xrayConfig, nil
+}
+
+func (s *XrayService) StartXray() error {
+	if s.IsXrayRunning() {
+		return nil
+	}
+
+	xrayConfig, err := s.GetXrayConfig()
+	if err != nil {
+		return err
+	}
+
+	p = xray.NewProcess(xrayConfig)
+	err = p.Start()
+	result = ""
+	return err
+}
+
+func (s *XrayService) StopXray() error {
+	if s.IsXrayRunning() {
+		return p.Stop()
+	}
+	return errors.New("xray is not running")
+}
+
+func (s *XrayService) RestartXray() error {
+	err1 := s.StopXray()
+	err2 := s.StartXray()
+	return common.Combine(err1, err2)
+}