mirror of
https://github.com/2dust/v2rayN.git
synced 2025-10-13 20:09:12 +00:00
292 lines
9.6 KiB
C#
292 lines
9.6 KiB
C#
namespace ServiceLib.Manager;
|
|
|
|
/// <summary>
|
|
/// Core process processing class
|
|
/// </summary>
|
|
public class CoreManager
|
|
{
|
|
private static readonly Lazy<CoreManager> _instance = new(() => new());
|
|
public static CoreManager Instance => _instance.Value;
|
|
private Config _config;
|
|
private WindowsJob? _processJob;
|
|
private ProcessService? _processService;
|
|
private ProcessService? _processPreService;
|
|
private bool _linuxSudo = false;
|
|
private Func<bool, string, Task>? _updateFunc;
|
|
private const string _tag = "CoreHandler";
|
|
|
|
public async Task Init(Config config, Func<bool, string, Task> updateFunc)
|
|
{
|
|
_config = config;
|
|
_updateFunc = updateFunc;
|
|
|
|
//Copy the bin folder to the storage location (for init)
|
|
if (Environment.GetEnvironmentVariable(Global.LocalAppData) == "1")
|
|
{
|
|
var fromPath = Utils.GetBaseDirectory("bin");
|
|
var toPath = Utils.GetBinPath("");
|
|
if (fromPath != toPath)
|
|
{
|
|
FileManager.CopyDirectory(fromPath, toPath, true, false);
|
|
}
|
|
}
|
|
|
|
if (Utils.IsNonWindows())
|
|
{
|
|
var coreInfo = CoreInfoManager.Instance.GetCoreInfo();
|
|
foreach (var it in coreInfo)
|
|
{
|
|
if (it.CoreType == ECoreType.v2rayN)
|
|
{
|
|
if (Utils.UpgradeAppExists(out var upgradeFileName))
|
|
{
|
|
await Utils.SetLinuxChmod(upgradeFileName);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
foreach (var name in it.CoreExes)
|
|
{
|
|
var exe = Utils.GetBinPath(Utils.GetExeName(name), it.CoreType.ToString());
|
|
if (File.Exists(exe))
|
|
{
|
|
await Utils.SetLinuxChmod(exe);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task LoadCore(ProfileItem? node)
|
|
{
|
|
if (node == null)
|
|
{
|
|
await UpdateFunc(false, ResUI.CheckServerSettings);
|
|
return;
|
|
}
|
|
|
|
var fileName = Utils.GetBinConfigPath(Global.CoreConfigFileName);
|
|
var result = await CoreConfigHandler.GenerateClientConfig(node, fileName);
|
|
if (result.Success != true)
|
|
{
|
|
await UpdateFunc(true, result.Msg);
|
|
return;
|
|
}
|
|
|
|
await UpdateFunc(false, $"{node.GetSummary()}");
|
|
await UpdateFunc(false, $"{Utils.GetRuntimeInfo()}");
|
|
await UpdateFunc(false, string.Format(ResUI.StartService, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")));
|
|
await CoreStop();
|
|
await Task.Delay(100);
|
|
|
|
if (Utils.IsWindows() && _config.TunModeItem.EnableTun)
|
|
{
|
|
await Task.Delay(100);
|
|
await WindowsUtils.RemoveTunDevice();
|
|
}
|
|
|
|
await CoreStart(node);
|
|
await CoreStartPreService(node);
|
|
if (_processService != null)
|
|
{
|
|
await UpdateFunc(true, $"{node.GetSummary()}");
|
|
}
|
|
}
|
|
|
|
public async Task<ProcessService?> 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));
|
|
var configPath = Utils.GetBinConfigPath(fileName);
|
|
var result = await CoreConfigHandler.GenerateClientSpeedtestConfig(_config, configPath, selecteds, coreType);
|
|
await UpdateFunc(false, result.Msg);
|
|
if (result.Success != true)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
public async Task<ProcessService?> LoadCoreConfigSpeedtest(ServerTestItem testItem)
|
|
{
|
|
var node = await AppManager.Instance.GetProfileItem(testItem.IndexId);
|
|
if (node is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var fileName = string.Format(Global.CoreSpeedtestConfigFileName, Utils.GetGuid(false));
|
|
var configPath = Utils.GetBinConfigPath(fileName);
|
|
var result = await CoreConfigHandler.GenerateClientSpeedtestConfig(_config, node, testItem, configPath);
|
|
if (result.Success != true)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var coreType = AppManager.Instance.GetCoreType(node, node.ConfigType);
|
|
var coreInfo = CoreInfoManager.Instance.GetCoreInfo(coreType);
|
|
return await RunProcess(coreInfo, fileName, true, false);
|
|
}
|
|
|
|
public async Task CoreStop()
|
|
{
|
|
try
|
|
{
|
|
if (_linuxSudo)
|
|
{
|
|
await CoreAdminManager.Instance.KillProcessAsLinuxSudo();
|
|
_linuxSudo = false;
|
|
}
|
|
|
|
if (_processService != null)
|
|
{
|
|
await _processService.StopAsync();
|
|
_processService.Dispose();
|
|
_processService = null;
|
|
}
|
|
|
|
if (_processPreService != null)
|
|
{
|
|
await _processPreService.StopAsync();
|
|
_processPreService.Dispose();
|
|
_processPreService = null;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logging.SaveLog(_tag, ex);
|
|
}
|
|
}
|
|
|
|
#region Private
|
|
|
|
private async Task CoreStart(ProfileItem node)
|
|
{
|
|
var coreType = _config.RunningCoreType = AppManager.Instance.GetCoreType(node, node.ConfigType);
|
|
var coreInfo = CoreInfoManager.Instance.GetCoreInfo(coreType);
|
|
|
|
var displayLog = node.ConfigType != EConfigType.Custom || node.DisplayLog;
|
|
var proc = await RunProcess(coreInfo, Global.CoreConfigFileName, displayLog, true);
|
|
if (proc is null)
|
|
{
|
|
return;
|
|
}
|
|
_processService = proc;
|
|
}
|
|
|
|
private async Task CoreStartPreService(ProfileItem node)
|
|
{
|
|
if (_processService != null && !_processService.HasExited)
|
|
{
|
|
var coreType = AppManager.Instance.GetCoreType(node, node.ConfigType);
|
|
var itemSocks = await ConfigHandler.GetPreSocksItem(_config, node, coreType);
|
|
if (itemSocks != null)
|
|
{
|
|
var preCoreType = itemSocks.CoreType ?? ECoreType.sing_box;
|
|
var fileName = Utils.GetBinConfigPath(Global.CorePreConfigFileName);
|
|
var result = await CoreConfigHandler.GenerateClientConfig(itemSocks, fileName);
|
|
if (result.Success)
|
|
{
|
|
var coreInfo = CoreInfoManager.Instance.GetCoreInfo(preCoreType);
|
|
var proc = await RunProcess(coreInfo, Global.CorePreConfigFileName, true, true);
|
|
if (proc is null)
|
|
{
|
|
return;
|
|
}
|
|
_processPreService = proc;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task UpdateFunc(bool notify, string msg)
|
|
{
|
|
await _updateFunc?.Invoke(notify, msg);
|
|
}
|
|
|
|
#endregion Private
|
|
|
|
#region Process
|
|
|
|
private async Task<ProcessService?> RunProcess(CoreInfo? coreInfo, string configPath, bool displayLog, bool mayNeedSudo)
|
|
{
|
|
var fileName = CoreInfoManager.Instance.GetCoreExecFile(coreInfo, out var msg);
|
|
if (fileName.IsNullOrEmpty())
|
|
{
|
|
await UpdateFunc(false, msg);
|
|
return null;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (mayNeedSudo
|
|
&& _config.TunModeItem.EnableTun
|
|
&& coreInfo.CoreType == ECoreType.sing_box
|
|
&& Utils.IsNonWindows())
|
|
{
|
|
_linuxSudo = true;
|
|
await CoreAdminManager.Instance.Init(_config, _updateFunc);
|
|
return await CoreAdminManager.Instance.RunProcessAsLinuxSudo(fileName, coreInfo, configPath);
|
|
}
|
|
|
|
return await RunProcessNormal(fileName, coreInfo, configPath, displayLog);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logging.SaveLog(_tag, ex);
|
|
await UpdateFunc(mayNeedSudo, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private async Task<ProcessService?> RunProcessNormal(string fileName, CoreInfo? coreInfo, string configPath, bool displayLog)
|
|
{
|
|
var environmentVars = new Dictionary<string, string>();
|
|
foreach (var kv in coreInfo.Environment)
|
|
{
|
|
environmentVars[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
|
|
);
|
|
|
|
await procService.StartAsync();
|
|
|
|
await Task.Delay(100);
|
|
|
|
if (procService is null or { HasExited: true })
|
|
{
|
|
throw new Exception(ResUI.FailedToRunCore);
|
|
}
|
|
AddProcessJob(procService.Handle);
|
|
|
|
return procService;
|
|
}
|
|
|
|
private void AddProcessJob(nint processHandle)
|
|
{
|
|
if (Utils.IsWindows())
|
|
{
|
|
_processJob ??= new();
|
|
try
|
|
{
|
|
_processJob?.AddProcess(processHandle);
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
|
|
#endregion Process
|
|
}
|