mirror of
https://github.com/MHSanaei/3x-ui.git
synced 2025-03-01 01:20:49 +03:00
501 lines
11 KiB
Go
501 lines
11 KiB
Go
package service
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"runtime"
|
|
"strings"
|
|
"time"
|
|
"x-ui/config"
|
|
"x-ui/database"
|
|
"x-ui/logger"
|
|
"x-ui/util/common"
|
|
"x-ui/util/sys"
|
|
"x-ui/xray"
|
|
|
|
"github.com/shirou/gopsutil/v3/cpu"
|
|
"github.com/shirou/gopsutil/v3/disk"
|
|
"github.com/shirou/gopsutil/v3/host"
|
|
"github.com/shirou/gopsutil/v3/load"
|
|
"github.com/shirou/gopsutil/v3/mem"
|
|
"github.com/shirou/gopsutil/v3/net"
|
|
)
|
|
|
|
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
|
|
inboundService InboundService
|
|
}
|
|
|
|
func (s *ServerService) GetStatus(lastStatus *Status) *Status {
|
|
now := time.Now()
|
|
status := &Status{
|
|
T: now,
|
|
}
|
|
|
|
percents, err := cpu.Percent(0, 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")
|
|
}
|
|
|
|
status.TcpCount, err = sys.GetTCPCount()
|
|
if err != nil {
|
|
logger.Warning("get tcp connections failed:", err)
|
|
}
|
|
|
|
status.UdpCount, err = sys.GetUDPCount()
|
|
if err != nil {
|
|
logger.Warning("get udp connections failed:", err)
|
|
}
|
|
|
|
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/mhsanaei/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) StopXrayService() (string error) {
|
|
|
|
err := s.xrayService.StopXray()
|
|
if err != nil {
|
|
logger.Error("stop xray failed:", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerService) RestartXrayService() (string error) {
|
|
|
|
s.xrayService.StopXray()
|
|
defer func() {
|
|
err := s.xrayService.RestartXray(true)
|
|
if err != nil {
|
|
logger.Error("start xray failed:", err)
|
|
}
|
|
}()
|
|
|
|
return 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/mhsanaei/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 func() {
|
|
err := s.xrayService.RestartXray(true)
|
|
if err != nil {
|
|
logger.Error("start xray failed:", err)
|
|
}
|
|
}()
|
|
|
|
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
|
|
}
|
|
err = copyZipFile("iran.dat", xray.GetIranPath())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *ServerService) GetLogs(count string) ([]string, error) {
|
|
// Define the journalctl command and its arguments
|
|
var cmdArgs []string
|
|
if runtime.GOOS == "linux" {
|
|
cmdArgs = []string{"journalctl", "-u", "x-ui", "--no-pager", "-n", count}
|
|
} else {
|
|
return []string{"Unsupported operating system"}, nil
|
|
}
|
|
|
|
// Run the command
|
|
cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
lines := strings.Split(out.String(), "\n")
|
|
|
|
return lines, nil
|
|
}
|
|
|
|
func (s *ServerService) GetConfigJson() (interface{}, error) {
|
|
// Open the file for reading
|
|
file, err := os.Open(xray.GetConfigPath())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
// Read the file contents
|
|
fileContents, err := io.ReadAll(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var jsonData interface{}
|
|
err = json.Unmarshal(fileContents, &jsonData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return jsonData, nil
|
|
}
|
|
|
|
func (s *ServerService) GetDb() ([]byte, error) {
|
|
// Open the file for reading
|
|
file, err := os.Open(config.GetDBPath())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
// Read the file contents
|
|
fileContents, err := io.ReadAll(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return fileContents, nil
|
|
}
|
|
|
|
func (s *ServerService) ImportDB(file multipart.File) error {
|
|
// Check if the file is a SQLite database
|
|
isValidDb, err := database.IsSQLiteDB(file)
|
|
if err != nil {
|
|
return common.NewErrorf("Error checking db file format: %v", err)
|
|
}
|
|
if !isValidDb {
|
|
return common.NewError("Invalid db file format")
|
|
}
|
|
|
|
// Save the file as temporary file
|
|
tempPath := fmt.Sprintf("%s.temp", config.GetDBPath())
|
|
// remove temp file before return
|
|
defer os.Remove(tempPath)
|
|
tempFile, err := os.Create(tempPath)
|
|
if err != nil {
|
|
return common.NewErrorf("Error creating temporary db file: %v", err)
|
|
}
|
|
defer tempFile.Close()
|
|
|
|
// Reset the file reader to the beginning
|
|
_, err = file.Seek(0, 0)
|
|
if err != nil {
|
|
return common.NewErrorf("Error resetting file reader: %v", err)
|
|
}
|
|
|
|
// Save temp file
|
|
_, err = io.Copy(tempFile, file)
|
|
if err != nil {
|
|
return common.NewErrorf("Error saving db: %v", err)
|
|
}
|
|
|
|
// Check if we can init db or not
|
|
err = database.InitDB(tempPath)
|
|
if err != nil {
|
|
return common.NewErrorf("Error checking db: %v", err)
|
|
}
|
|
|
|
// Stop Xray
|
|
s.StopXrayService()
|
|
|
|
// Backup db for fallback
|
|
fallbackPath := fmt.Sprintf("%s.backup", config.GetDBPath())
|
|
// remove fallback file before return
|
|
defer os.Remove(fallbackPath)
|
|
err = os.Rename(config.GetDBPath(), fallbackPath)
|
|
if err != nil {
|
|
return common.NewErrorf("Error backup temporary db file: %v", err)
|
|
}
|
|
|
|
// Move temp to DB path
|
|
err = os.Rename(tempPath, config.GetDBPath())
|
|
if err != nil {
|
|
os.Rename(fallbackPath, config.GetDBPath())
|
|
return common.NewErrorf("Error moving db file: %v", err)
|
|
}
|
|
|
|
// Migrate DB
|
|
err = database.InitDB(config.GetDBPath())
|
|
if err != nil {
|
|
os.Rename(fallbackPath, config.GetDBPath())
|
|
return common.NewErrorf("Error migrating db: %v", err)
|
|
}
|
|
s.inboundService.MigrateDB()
|
|
|
|
// Start Xray
|
|
err = s.RestartXrayService()
|
|
if err != nil {
|
|
return common.NewErrorf("Imported DB but Failed to start Xray: %v", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerService) GetNewX25519Cert() (interface{}, error) {
|
|
// Run the command
|
|
cmd := exec.Command(xray.GetBinaryPath(), "x25519")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
lines := strings.Split(out.String(), "\n")
|
|
|
|
privateKeyLine := strings.Split(lines[0], ":")
|
|
publicKeyLine := strings.Split(lines[1], ":")
|
|
|
|
privateKey := strings.TrimSpace(privateKeyLine[1])
|
|
publicKey := strings.TrimSpace(publicKeyLine[1])
|
|
|
|
keyPair := map[string]interface{}{
|
|
"privateKey": privateKey,
|
|
"publicKey": publicKey,
|
|
}
|
|
|
|
return keyPair, nil
|
|
}
|