mirror of
https://github.com/MHSanaei/3x-ui.git
synced 2026-01-13 01:02:46 +00:00
445 lines
12 KiB
Go
445 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"runtime"
|
|
"sync"
|
|
|
|
"github.com/mhsanaei/3x-ui/v2/database/model"
|
|
"github.com/mhsanaei/3x-ui/v2/logger"
|
|
"github.com/mhsanaei/3x-ui/v2/xray"
|
|
|
|
"go.uber.org/atomic"
|
|
)
|
|
|
|
var (
|
|
p *xray.Process
|
|
lock sync.Mutex
|
|
isNeedXrayRestart atomic.Bool // Indicates that restart was requested for Xray
|
|
isManuallyStopped atomic.Bool // Indicates that Xray was stopped manually from the panel
|
|
result string
|
|
)
|
|
|
|
// XrayService provides business logic for Xray process management.
|
|
// It handles starting, stopping, restarting Xray, and managing its configuration.
|
|
// In multi-node mode, it sends configurations to nodes instead of running Xray locally.
|
|
type XrayService struct {
|
|
inboundService InboundService
|
|
settingService SettingService
|
|
nodeService NodeService
|
|
xrayAPI xray.XrayAPI
|
|
}
|
|
|
|
// IsXrayRunning checks if the Xray process is currently running.
|
|
func (s *XrayService) IsXrayRunning() bool {
|
|
return p != nil && p.IsRunning()
|
|
}
|
|
|
|
// GetXrayErr returns the error from the Xray process, if any.
|
|
func (s *XrayService) GetXrayErr() error {
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
|
|
err := p.GetErr()
|
|
|
|
if runtime.GOOS == "windows" && err.Error() == "exit status 1" {
|
|
// exit status 1 on Windows means that Xray process was killed
|
|
// as we kill process to stop in on Windows, this is not an error
|
|
return nil
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// GetXrayResult returns the result string from the Xray process.
|
|
func (s *XrayService) GetXrayResult() string {
|
|
if result != "" {
|
|
return result
|
|
}
|
|
if s.IsXrayRunning() {
|
|
return ""
|
|
}
|
|
if p == nil {
|
|
return ""
|
|
}
|
|
|
|
result = p.GetResult()
|
|
|
|
if runtime.GOOS == "windows" && result == "exit status 1" {
|
|
// exit status 1 on Windows means that Xray process was killed
|
|
// as we kill process to stop in on Windows, this is not an error
|
|
return ""
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// GetXrayVersion returns the version of the running Xray process.
|
|
func (s *XrayService) GetXrayVersion() string {
|
|
if p == nil {
|
|
return "Unknown"
|
|
}
|
|
return p.GetVersion()
|
|
}
|
|
|
|
// RemoveIndex removes an element at the specified index from a slice.
|
|
// Returns a new slice with the element removed.
|
|
func RemoveIndex(s []any, index int) []any {
|
|
return append(s[:index], s[index+1:]...)
|
|
}
|
|
|
|
// GetXrayConfig retrieves and builds the Xray configuration from settings and inbounds.
|
|
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
|
|
}
|
|
|
|
s.inboundService.AddTraffic(nil, nil)
|
|
|
|
inbounds, err := s.inboundService.GetAllInbounds()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, inbound := range inbounds {
|
|
if !inbound.Enable {
|
|
continue
|
|
}
|
|
// get settings clients
|
|
settings := map[string]any{}
|
|
json.Unmarshal([]byte(inbound.Settings), &settings)
|
|
clients, ok := settings["clients"].([]any)
|
|
if ok {
|
|
// check users active or not
|
|
clientStats := inbound.ClientStats
|
|
for _, clientTraffic := range clientStats {
|
|
indexDecrease := 0
|
|
for index, client := range clients {
|
|
c := client.(map[string]any)
|
|
if c["email"] == clientTraffic.Email {
|
|
if !clientTraffic.Enable {
|
|
clients = RemoveIndex(clients, index-indexDecrease)
|
|
indexDecrease++
|
|
logger.Infof("Remove Inbound User %s due to expiration or traffic limit", c["email"])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// clear client config for additional parameters
|
|
var final_clients []any
|
|
for _, client := range clients {
|
|
c := client.(map[string]any)
|
|
if c["enable"] != nil {
|
|
if enable, ok := c["enable"].(bool); ok && !enable {
|
|
continue
|
|
}
|
|
}
|
|
for key := range c {
|
|
if key != "email" && key != "id" && key != "password" && key != "flow" && key != "method" {
|
|
delete(c, key)
|
|
}
|
|
if c["flow"] == "xtls-rprx-vision-udp443" {
|
|
c["flow"] = "xtls-rprx-vision"
|
|
}
|
|
}
|
|
final_clients = append(final_clients, any(c))
|
|
}
|
|
|
|
settings["clients"] = final_clients
|
|
modifiedSettings, err := json.MarshalIndent(settings, "", " ")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
inbound.Settings = string(modifiedSettings)
|
|
}
|
|
|
|
if len(inbound.StreamSettings) > 0 {
|
|
// Unmarshal stream JSON
|
|
var stream map[string]any
|
|
json.Unmarshal([]byte(inbound.StreamSettings), &stream)
|
|
|
|
// Remove the "settings" field under "tlsSettings" and "realitySettings"
|
|
tlsSettings, ok1 := stream["tlsSettings"].(map[string]any)
|
|
realitySettings, ok2 := stream["realitySettings"].(map[string]any)
|
|
if ok1 || ok2 {
|
|
if ok1 {
|
|
delete(tlsSettings, "settings")
|
|
} else if ok2 {
|
|
delete(realitySettings, "settings")
|
|
}
|
|
}
|
|
|
|
delete(stream, "externalProxy")
|
|
|
|
newStream, err := json.MarshalIndent(stream, "", " ")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
inbound.StreamSettings = string(newStream)
|
|
}
|
|
|
|
inboundConfig := inbound.GenXrayInboundConfig()
|
|
xrayConfig.InboundConfigs = append(xrayConfig.InboundConfigs, *inboundConfig)
|
|
}
|
|
return xrayConfig, nil
|
|
}
|
|
|
|
// GetXrayTraffic fetches the current traffic statistics from the running Xray process.
|
|
func (s *XrayService) GetXrayTraffic() ([]*xray.Traffic, []*xray.ClientTraffic, error) {
|
|
if !s.IsXrayRunning() {
|
|
err := errors.New("xray is not running")
|
|
logger.Debug("Attempted to fetch Xray traffic, but Xray is not running:", err)
|
|
return nil, nil, err
|
|
}
|
|
apiPort := p.GetAPIPort()
|
|
s.xrayAPI.Init(apiPort)
|
|
defer s.xrayAPI.Close()
|
|
|
|
traffic, clientTraffic, err := s.xrayAPI.GetTraffic(true)
|
|
if err != nil {
|
|
logger.Debug("Failed to fetch Xray traffic:", err)
|
|
return nil, nil, err
|
|
}
|
|
return traffic, clientTraffic, nil
|
|
}
|
|
|
|
// RestartXray restarts the Xray process, optionally forcing a restart even if config unchanged.
|
|
// In multi-node mode, it sends configurations to nodes instead of restarting local Xray.
|
|
func (s *XrayService) RestartXray(isForce bool) error {
|
|
lock.Lock()
|
|
defer lock.Unlock()
|
|
logger.Debug("restart Xray, force:", isForce)
|
|
isManuallyStopped.Store(false)
|
|
|
|
// Check if multi-node mode is enabled
|
|
multiMode, err := s.settingService.GetMultiNodeMode()
|
|
if err != nil {
|
|
multiMode = false // Default to single mode on error
|
|
}
|
|
|
|
if multiMode {
|
|
return s.restartXrayMultiMode(isForce)
|
|
}
|
|
|
|
// Single mode: use local Xray
|
|
xrayConfig, err := s.GetXrayConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if s.IsXrayRunning() {
|
|
if !isForce && p.GetConfig().Equals(xrayConfig) && !isNeedXrayRestart.Load() {
|
|
logger.Debug("It does not need to restart Xray")
|
|
return nil
|
|
}
|
|
p.Stop()
|
|
}
|
|
|
|
p = xray.NewProcess(xrayConfig)
|
|
result = ""
|
|
err = p.Start()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// restartXrayMultiMode handles Xray restart in multi-node mode by sending configs to nodes.
|
|
func (s *XrayService) restartXrayMultiMode(isForce bool) error {
|
|
// Initialize nodeService if not already initialized
|
|
if s.nodeService == (NodeService{}) {
|
|
s.nodeService = NodeService{}
|
|
}
|
|
|
|
// Get all nodes
|
|
nodes, err := s.nodeService.GetAllNodes()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get nodes: %w", err)
|
|
}
|
|
|
|
// Group inbounds by node
|
|
nodeInbounds := make(map[int][]*model.Inbound)
|
|
allInbounds, err := s.inboundService.GetAllInbounds()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get inbounds: %w", err)
|
|
}
|
|
|
|
// Get template config
|
|
templateConfig, err := s.settingService.GetXrayConfigTemplate()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
baseConfig := &xray.Config{}
|
|
if err := json.Unmarshal([]byte(templateConfig), baseConfig); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Group inbounds by their assigned nodes
|
|
for _, inbound := range allInbounds {
|
|
if !inbound.Enable {
|
|
continue
|
|
}
|
|
|
|
// Get all nodes assigned to this inbound (multi-node support)
|
|
nodes, err := s.nodeService.GetNodesForInbound(inbound.Id)
|
|
if err != nil || len(nodes) == 0 {
|
|
// Inbound not assigned to any node, skip it (this is normal - not all inbounds need to be assigned)
|
|
logger.Debugf("Inbound %d is not assigned to any node, skipping", inbound.Id)
|
|
continue
|
|
}
|
|
|
|
// Add inbound to all assigned nodes
|
|
for _, node := range nodes {
|
|
nodeInbounds[node.Id] = append(nodeInbounds[node.Id], inbound)
|
|
}
|
|
}
|
|
|
|
// Send config to each node
|
|
for _, node := range nodes {
|
|
inbounds, ok := nodeInbounds[node.Id]
|
|
if !ok {
|
|
// No inbounds assigned to this node, skip
|
|
continue
|
|
}
|
|
|
|
// Build config for this node
|
|
nodeConfig := *baseConfig
|
|
// Preserve API inbound from template (if exists)
|
|
apiInbound := xray.InboundConfig{}
|
|
hasAPIInbound := false
|
|
for _, inbound := range baseConfig.InboundConfigs {
|
|
if inbound.Tag == "api" {
|
|
apiInbound = inbound
|
|
hasAPIInbound = true
|
|
break
|
|
}
|
|
}
|
|
nodeConfig.InboundConfigs = []xray.InboundConfig{}
|
|
// Add API inbound first if it exists
|
|
if hasAPIInbound {
|
|
nodeConfig.InboundConfigs = append(nodeConfig.InboundConfigs, apiInbound)
|
|
}
|
|
|
|
for _, inbound := range inbounds {
|
|
// Process clients (same logic as GetXrayConfig)
|
|
settings := map[string]any{}
|
|
json.Unmarshal([]byte(inbound.Settings), &settings)
|
|
clients, ok := settings["clients"].([]any)
|
|
if ok {
|
|
clientStats := inbound.ClientStats
|
|
for _, clientTraffic := range clientStats {
|
|
indexDecrease := 0
|
|
for index, client := range clients {
|
|
c := client.(map[string]any)
|
|
if c["email"] == clientTraffic.Email {
|
|
if !clientTraffic.Enable {
|
|
clients = RemoveIndex(clients, index-indexDecrease)
|
|
indexDecrease++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var final_clients []any
|
|
for _, client := range clients {
|
|
c := client.(map[string]any)
|
|
if c["enable"] != nil {
|
|
if enable, ok := c["enable"].(bool); ok && !enable {
|
|
continue
|
|
}
|
|
}
|
|
for key := range c {
|
|
if key != "email" && key != "id" && key != "password" && key != "flow" && key != "method" {
|
|
delete(c, key)
|
|
}
|
|
if c["flow"] == "xtls-rprx-vision-udp443" {
|
|
c["flow"] = "xtls-rprx-vision"
|
|
}
|
|
}
|
|
final_clients = append(final_clients, any(c))
|
|
}
|
|
|
|
settings["clients"] = final_clients
|
|
modifiedSettings, _ := json.MarshalIndent(settings, "", " ")
|
|
inbound.Settings = string(modifiedSettings)
|
|
}
|
|
|
|
if len(inbound.StreamSettings) > 0 {
|
|
var stream map[string]any
|
|
json.Unmarshal([]byte(inbound.StreamSettings), &stream)
|
|
tlsSettings, ok1 := stream["tlsSettings"].(map[string]any)
|
|
realitySettings, ok2 := stream["realitySettings"].(map[string]any)
|
|
if ok1 || ok2 {
|
|
if ok1 {
|
|
delete(tlsSettings, "settings")
|
|
} else if ok2 {
|
|
delete(realitySettings, "settings")
|
|
}
|
|
}
|
|
delete(stream, "externalProxy")
|
|
newStream, _ := json.MarshalIndent(stream, "", " ")
|
|
inbound.StreamSettings = string(newStream)
|
|
}
|
|
|
|
inboundConfig := inbound.GenXrayInboundConfig()
|
|
nodeConfig.InboundConfigs = append(nodeConfig.InboundConfigs, *inboundConfig)
|
|
}
|
|
|
|
// Marshal config to JSON
|
|
configJSON, err := json.MarshalIndent(&nodeConfig, "", " ")
|
|
if err != nil {
|
|
logger.Errorf("[Node: %s] Failed to marshal config: %v", node.Name, err)
|
|
continue
|
|
}
|
|
|
|
// Send to node
|
|
if err := s.nodeService.ApplyConfigToNode(node, configJSON); err != nil {
|
|
logger.Errorf("[Node: %s] Failed to apply config: %v", node.Name, err)
|
|
// Continue with other nodes even if one fails
|
|
} else {
|
|
logger.Infof("[Node: %s] Successfully applied config", node.Name)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// StopXray stops the running Xray process.
|
|
func (s *XrayService) StopXray() error {
|
|
lock.Lock()
|
|
defer lock.Unlock()
|
|
isManuallyStopped.Store(true)
|
|
logger.Debug("Attempting to stop Xray...")
|
|
if s.IsXrayRunning() {
|
|
return p.Stop()
|
|
}
|
|
return errors.New("xray is not running")
|
|
}
|
|
|
|
// SetToNeedRestart marks that Xray needs to be restarted.
|
|
func (s *XrayService) SetToNeedRestart() {
|
|
isNeedXrayRestart.Store(true)
|
|
}
|
|
|
|
// IsNeedRestartAndSetFalse checks if restart is needed and resets the flag to false.
|
|
func (s *XrayService) IsNeedRestartAndSetFalse() bool {
|
|
return isNeedXrayRestart.CompareAndSwap(true, false)
|
|
}
|
|
|
|
// DidXrayCrash checks if Xray crashed by verifying it's not running and wasn't manually stopped.
|
|
func (s *XrayService) DidXrayCrash() bool {
|
|
return !s.IsXrayRunning() && !isManuallyStopped.Load()
|
|
}
|