Merge 6250810f31 into e970372a9f

v2rayN/ServiceLib/Manager/CoreAdminManager.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.Text;
 using CliWrap;
 using CliWrap.Buffered;
@@ -30,7 +31,7 @@ public class CoreAdminManager
         await _updateFunc?.Invoke(notify, msg);
     }
 
-    public async Task<ProcessService?> RunProcessAsLinuxSudo(string fileName, CoreInfo coreInfo, string configPath)
+    public async Task<Process?> RunProcessAsLinuxSudo(string fileName, CoreInfo coreInfo, string configPath)
     {
         StringBuilder sb = new();
         sb.AppendLine("#!/bin/bash");
@@ -38,25 +39,50 @@ public class CoreAdminManager
         sb.AppendLine($"sudo -S {cmdLine}");
         var shFilePath = await FileManager.CreateLinuxShellFile("run_as_sudo.sh", sb.ToString(), true);
 
-        var procService = new ProcessService(
-            fileName: shFilePath,
-            arguments: "",
-            workingDirectory: Utils.GetBinConfigPath(),
-            displayLog: true,
-            redirectInput: true,
-            environmentVars: null,
-            updateFunc: _updateFunc
-        );
+        Process proc = new()
+        {
+            StartInfo = new()
+            {
+                FileName = shFilePath,
+                Arguments = "",
+                WorkingDirectory = Utils.GetBinConfigPath(),
+                UseShellExecute = false,
+                RedirectStandardInput = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true,
+                StandardOutputEncoding = Encoding.UTF8,
+                StandardErrorEncoding = Encoding.UTF8,
+            }
+        };
 
-        await procService.StartAsync(AppManager.Instance.LinuxSudoPwd);
+        void dataHandler(object sender, DataReceivedEventArgs e)
+        {
+            if (e.Data.IsNotEmpty())
+            {
+                _ = UpdateFunc(false, e.Data + Environment.NewLine);
+            }
+        }
 
-        if (procService is null or { HasExited: true })
+        proc.OutputDataReceived += dataHandler;
+        proc.ErrorDataReceived += dataHandler;
+
+        proc.Start();
+        proc.BeginOutputReadLine();
+        proc.BeginErrorReadLine();
+
+        await Task.Delay(10);
+        await proc.StandardInput.WriteLineAsync(AppManager.Instance.LinuxSudoPwd);
+
+        await Task.Delay(100);
+        if (proc is null or { HasExited: true })
         {
             throw new Exception(ResUI.FailedToRunCore);
         }
-        _linuxSudoPid = procService.Id;
 
-        return procService;
+        _linuxSudoPid = proc.Id;
+
+        return proc;
     }
 
     public async Task KillProcessAsLinuxSudo()

v2rayN/ServiceLib/Manager/CoreManager.cs

@@ -1,3 +1,6 @@
+using System.Diagnostics;
+using System.Text;
+
 namespace ServiceLib.Manager;
 
 /// <summary>
@@ -8,8 +11,8 @@ public class CoreManager
     private static readonly Lazy<CoreManager> _instance = new(() => new());
     public static CoreManager Instance => _instance.Value;
     private Config _config;
-    private ProcessService? _processService;
-    private ProcessService? _processPreService;
+    private Process? _process;
+    private Process? _processPre;
     private bool _linuxSudo = false;
     private Func<bool, string, Task>? _updateFunc;
     private const string _tag = "CoreHandler";
@@ -86,13 +89,13 @@ public class CoreManager
 
         await CoreStart(node);
         await CoreStartPreService(node);
-        if (_processService != null)
+        if (_process != null)
         {
             await UpdateFunc(true, $"{node.GetSummary()}");
         }
     }
 
-    public async Task<ProcessService?> LoadCoreConfigSpeedtest(List<ServerTestItem> selecteds)
+    public async Task<int> LoadCoreConfigSpeedtest(List<ServerTestItem> selecteds)
     {
         var coreType = selecteds.Exists(t => t.ConfigType is EConfigType.Hysteria2 or EConfigType.TUIC or EConfigType.Anytls) ? ECoreType.sing_box : ECoreType.Xray;
         var fileName = string.Format(Global.CoreSpeedtestConfigFileName, Utils.GetGuid(false));
@@ -101,22 +104,28 @@ public class CoreManager
         await UpdateFunc(false, result.Msg);
         if (result.Success != true)
         {
-            return null;
+            return -1;
         }
 
         await UpdateFunc(false, string.Format(ResUI.StartService, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")));
         await UpdateFunc(false, configPath);
 
         var coreInfo = CoreInfoManager.Instance.GetCoreInfo(coreType);
-        return await RunProcess(coreInfo, fileName, true, false);
+        var proc = await RunProcess(coreInfo, fileName, true, false);
+        if (proc is null)
+        {
+            return -1;
+        }
+
+        return proc.Id;
     }
 
-    public async Task<ProcessService?> LoadCoreConfigSpeedtest(ServerTestItem testItem)
+    public async Task<int> LoadCoreConfigSpeedtest(ServerTestItem testItem)
     {
         var node = await AppManager.Instance.GetProfileItem(testItem.IndexId);
         if (node is null)
         {
-            return null;
+            return -1;
         }
 
         var fileName = string.Format(Global.CoreSpeedtestConfigFileName, Utils.GetGuid(false));
@@ -124,12 +133,18 @@ public class CoreManager
         var result = await CoreConfigHandler.GenerateClientSpeedtestConfig(_config, node, testItem, configPath);
         if (result.Success != true)
         {
-            return null;
+            return -1;
         }
 
         var coreType = AppManager.Instance.GetCoreType(node, node.ConfigType);
         var coreInfo = CoreInfoManager.Instance.GetCoreInfo(coreType);
-        return await RunProcess(coreInfo, fileName, true, false);
+        var proc = await RunProcess(coreInfo, fileName, true, false);
+        if (proc is null)
+        {
+            return -1;
+        }
+
+        return proc.Id;
     }
 
     public async Task CoreStop()
@@ -142,18 +157,16 @@ public class CoreManager
                 _linuxSudo = false;
             }
 
-            if (_processService != null)
+            if (_process != null)
             {
-                await _processService.StopAsync();
-                _processService.Dispose();
-                _processService = null;
+                await ProcUtils.ProcessKill(_process, Utils.IsWindows());
+                _process = null;
             }
 
-            if (_processPreService != null)
+            if (_processPre != null)
             {
-                await _processPreService.StopAsync();
-                _processPreService.Dispose();
-                _processPreService = null;
+                await ProcUtils.ProcessKill(_processPre, Utils.IsWindows());
+                _processPre = null;
             }
         }
         catch (Exception ex)
@@ -175,12 +188,12 @@ public class CoreManager
         {
             return;
         }
-        _processService = proc;
+        _process = proc;
     }
 
     private async Task CoreStartPreService(ProfileItem node)
     {
-        if (_processService != null && !_processService.HasExited)
+        if (_process != null && !_process.HasExited)
         {
             var coreType = AppManager.Instance.GetCoreType(node, node.ConfigType);
             var itemSocks = await ConfigHandler.GetPreSocksItem(_config, node, coreType);
@@ -197,7 +210,7 @@ public class CoreManager
                     {
                         return;
                     }
-                    _processPreService = proc;
+                    _processPre = proc;
                 }
             }
         }
@@ -212,7 +225,7 @@ public class CoreManager
 
     #region Process
 
-    private async Task<ProcessService?> RunProcess(CoreInfo? coreInfo, string configPath, bool displayLog, bool mayNeedSudo)
+    private async Task<Process?> RunProcess(CoreInfo? coreInfo, string configPath, bool displayLog, bool mayNeedSudo)
     {
         var fileName = CoreInfoManager.Instance.GetCoreExecFile(coreInfo, out var msg);
         if (fileName.IsNullOrEmpty())
@@ -243,34 +256,55 @@ public class CoreManager
         }
     }
 
-    private async Task<ProcessService?> RunProcessNormal(string fileName, CoreInfo? coreInfo, string configPath, bool displayLog)
+    private async Task<Process?> RunProcessNormal(string fileName, CoreInfo? coreInfo, string configPath, bool displayLog)
     {
-        var environmentVars = new Dictionary<string, string>();
+        Process proc = new()
+        {
+            StartInfo = new()
+            {
+                FileName = fileName,
+                Arguments = string.Format(coreInfo.Arguments, coreInfo.AbsolutePath ? Utils.GetBinConfigPath(configPath).AppendQuotes() : configPath),
+                WorkingDirectory = Utils.GetBinConfigPath(),
+                UseShellExecute = false,
+                RedirectStandardOutput = displayLog,
+                RedirectStandardError = displayLog,
+                CreateNoWindow = true,
+                StandardOutputEncoding = displayLog ? Encoding.UTF8 : null,
+                StandardErrorEncoding = displayLog ? Encoding.UTF8 : null,
+            }
+        };
         foreach (var kv in coreInfo.Environment)
         {
-            environmentVars[kv.Key] = string.Format(kv.Value, coreInfo.AbsolutePath ? Utils.GetBinConfigPath(configPath).AppendQuotes() : configPath);
+            proc.StartInfo.Environment[kv.Key] = string.Format(kv.Value, coreInfo.AbsolutePath ? Utils.GetBinConfigPath(configPath).AppendQuotes() : configPath);
         }
 
-        var procService = new ProcessService(
-            fileName: fileName,
-            arguments: string.Format(coreInfo.Arguments, coreInfo.AbsolutePath ? Utils.GetBinConfigPath(configPath).AppendQuotes() : configPath),
-            workingDirectory: Utils.GetBinConfigPath(),
-            displayLog: displayLog,
-            redirectInput: false,
-            environmentVars: environmentVars,
-            updateFunc: _updateFunc
-        );
+        if (displayLog)
+        {
+            void dataHandler(object sender, DataReceivedEventArgs e)
+            {
+                if (e.Data.IsNotEmpty())
+                {
+                    _ = UpdateFunc(false, e.Data + Environment.NewLine);
+                }
+            }
+            proc.OutputDataReceived += dataHandler;
+            proc.ErrorDataReceived += dataHandler;
+        }
+        proc.Start();
 
-        await procService.StartAsync();
+        if (displayLog)
+        {
+            proc.BeginOutputReadLine();
+            proc.BeginErrorReadLine();
+        }
 
         await Task.Delay(100);
-        AppManager.Instance.AddProcess(procService.Handle);
-        if (procService is null or { HasExited: true })
+        AppManager.Instance.AddProcess(proc.Handle);
+        if (proc is null or { HasExited: true })
         {
             throw new Exception(ResUI.FailedToRunCore);
         }
-
-        return procService;
+        return proc;
     }
 
     #endregion Process

v2rayN/ServiceLib/Services/ProcessService.cs

@@ -1,182 +0,0 @@
-using System.Diagnostics;
-using System.Text;
-
-namespace ServiceLib.Services;
-
-public class ProcessService : IDisposable
-{
-    private readonly Process _process;
-    private readonly Func<bool, string, Task>? _updateFunc;
-    private bool _isDisposed;
-
-    public int Id => _process.Id;
-    public IntPtr Handle => _process.Handle;
-    public bool HasExited => _process.HasExited;
-
-    public ProcessService(
-        string fileName,
-        string arguments,
-        string workingDirectory,
-        bool displayLog,
-        bool redirectInput,
-        Dictionary<string, string>? environmentVars,
-        Func<bool, string, Task>? updateFunc)
-    {
-        _updateFunc = updateFunc;
-
-        _process = new Process
-        {
-            StartInfo = new ProcessStartInfo
-            {
-                FileName = fileName,
-                Arguments = arguments,
-                WorkingDirectory = workingDirectory,
-                UseShellExecute = false,
-                RedirectStandardInput = redirectInput,
-                RedirectStandardOutput = displayLog,
-                RedirectStandardError = displayLog,
-                CreateNoWindow = true,
-                StandardOutputEncoding = displayLog ? Encoding.UTF8 : null,
-                StandardErrorEncoding = displayLog ? Encoding.UTF8 : null,
-            },
-            EnableRaisingEvents = true
-        };
-
-        if (environmentVars != null)
-        {
-            foreach (var kv in environmentVars)
-            {
-                _process.StartInfo.Environment[kv.Key] = kv.Value;
-            }
-        }
-
-        if (displayLog)
-        {
-            RegisterEventHandlers();
-        }
-    }
-
-    public async Task StartAsync(string pwd = null)
-    {
-        _process.Start();
-
-        if (_process.StartInfo.RedirectStandardOutput)
-        {
-            _process.BeginOutputReadLine();
-            _process.BeginErrorReadLine();
-        }
-
-        if (_process.StartInfo.RedirectStandardInput)
-        {
-            await Task.Delay(10);
-            await _process.StandardInput.WriteLineAsync(pwd);
-        }
-    }
-
-    public async Task StopAsync()
-    {
-        if (_process.HasExited)
-        {
-            return;
-        }
-
-        try
-        {
-            if (_process.StartInfo.RedirectStandardOutput)
-            {
-                try
-                {
-                    _process.CancelOutputRead();
-                }
-                catch { }
-                try
-                {
-                    _process.CancelErrorRead();
-                }
-                catch { }
-            }
-
-            try
-            {
-                if (Utils.IsNonWindows())
-                {
-                    _process.Kill(true);
-                }
-            }
-            catch { }
-
-            try
-            {
-                _process.Kill();
-            }
-            catch { }
-
-            await Task.Delay(100);
-        }
-        catch (Exception ex)
-        {
-            await _updateFunc?.Invoke(true, ex.Message);
-        }
-    }
-
-    private void RegisterEventHandlers()
-    {
-        void dataHandler(object sender, DataReceivedEventArgs e)
-        {
-            if (e.Data.IsNotEmpty())
-            {
-                _ = _updateFunc?.Invoke(false, e.Data + Environment.NewLine);
-            }
-        }
-
-        _process.OutputDataReceived += dataHandler;
-        _process.ErrorDataReceived += dataHandler;
-
-        _process.Exited += (s, e) =>
-        {
-            try
-            {
-                _process.OutputDataReceived -= dataHandler;
-                _process.ErrorDataReceived -= dataHandler;
-            }
-            catch
-            {
-            }
-        };
-    }
-
-    public void Dispose()
-    {
-        if (_isDisposed)
-        {
-            return;
-        }
-
-        try
-        {
-            if (!_process.HasExited)
-            {
-                try
-                {
-                    _process.CancelOutputRead();
-                }
-                catch { }
-                try
-                {
-                    _process.CancelErrorRead();
-                }
-                catch { }
-
-                _process.Kill();
-            }
-
-            _process.Dispose();
-        }
-        catch (Exception ex)
-        {
-            _updateFunc?.Invoke(true, ex.Message);
-        }
-
-        _isDisposed = true;
-    }
-}

v2rayN/ServiceLib/Services/SpeedtestService.cs

@@ -182,11 +182,11 @@ public class SpeedtestService(Config config, Func<SpeedTestResult, Task> updateF
 
     private async Task<bool> RunRealPingAsync(List<ServerTestItem> selecteds, string exitLoopKey)
     {
-        ProcessService processService = null;
+        var pid = -1;
         try
         {
-            processService = await CoreManager.Instance.LoadCoreConfigSpeedtest(selecteds);
-            if (processService is null)
+            pid = await CoreManager.Instance.LoadCoreConfigSpeedtest(selecteds);
+            if (pid < 0)
             {
                 return false;
             }
@@ -216,7 +216,10 @@ public class SpeedtestService(Config config, Func<SpeedTestResult, Task> updateF
         }
         finally
         {
-            await processService?.StopAsync();
+            if (pid > 0)
+            {
+                await ProcUtils.ProcessKill(pid);
+            }
         }
         return true;
     }
@@ -241,11 +244,11 @@ public class SpeedtestService(Config config, Func<SpeedTestResult, Task> updateF
 
             tasks.Add(Task.Run(async () =>
             {
-                ProcessService processService = null;
+                var pid = -1;
                 try
                 {
-                    processService = await CoreManager.Instance.LoadCoreConfigSpeedtest(it);
-                    if (processService is null)
+                    pid = await CoreManager.Instance.LoadCoreConfigSpeedtest(it);
+                    if (pid < 0)
                     {
                         await UpdateFunc(it.IndexId, "", ResUI.FailedToRunCore);
                     }
@@ -272,7 +275,10 @@ public class SpeedtestService(Config config, Func<SpeedTestResult, Task> updateF
                 }
                 finally
                 {
-                    await processService?.StopAsync();
+                    if (pid > 0)
+                    {
+                        await ProcUtils.ProcessKill(pid);
+                    }
                     concurrencySemaphore.Release();
                 }
             }));