Revert "去掉 IPC 实现，因为 AOT 之后居然有 20 MB 大小"

This reverts commit 2b66683.

Author: lindexi

src/MediaConverters/MediaConverters.Tool/CommandLineHandlers/IpcHandlers/IpcHandler.cs

@@ -0,0 +1,155 @@
+using System;
+using dotnetCampus.Ipc.Context;
+using dotnetCampus.Ipc.IpcRouteds.DirectRouteds;
+using dotnetCampus.Ipc.Pipes;
+using dotnetCampus.Ipc.Threading;
+using dotnetCampus.Ipc.Utils.Buffers;
+
+using DotNetCampus.Cli;
+using DotNetCampus.Cli.Compiler;
+using DotNetCampus.MediaConverters.Contexts;
+using DotNetCampus.MediaConverters.Contexts.IpcContexts;
+
+using System.Buffers;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DotNetCampus.MediaConverters.CommandLineHandlers;
+
+public class IpcHandler : ICommandHandler
+{
+    [Option]
+    public required string IpcName { get; init; }
+
+    /// <summary>
+    /// 总的工作路径，可用在后续的转换过程中，存放日志或过程文件等
+    /// </summary>
+    [Option]
+    public required string WorkingFolder { get; init; }
+
+    [Option]
+    public bool? ShouldLogToConsole { get; init; }
+
+    [Option]
+    public bool? ShouldLogToFile { get; init; }
+
+    public async Task<int> RunAsync()
+    {
+        var ipcConfiguration = new IpcConfiguration()
+        {
+            AutoReconnectPeers = false,
+            IpcLoggerProvider = name => new MediaConverterIpcLogger(name, this),
+
+            // 以下为默认配置
+            SharedArrayPool = new SharedArrayPool(ArrayPool<byte>.Shared),
+            IpcTaskScheduling = IpcTaskScheduling.GlobalConcurrent,
+        };
+        ipcConfiguration.UseSystemJsonIpcObjectSerializer(MediaConverterJsonSerializerSourceGenerationContext.Default);
+
+        var ipcProvider = new IpcProvider(IpcName, ipcConfiguration);
+
+        var ipcHandlerLogger = new IpcHandlerLogger(this);
+        var exitTaskCompletionSource = new TaskCompletionSource<int>();
+
+        var jsonIpcDirectRoutedProvider = new JsonIpcDirectRoutedProvider(ipcProvider);
+
+        jsonIpcDirectRoutedProvider.AddRequestHandler(IpcPaths.RequestConvertImage, async (IpcConvertImageRequest request) =>
+        {
+            if (request.InputFile is null || request.OutputFile is null || request.ConvertConfigurationFile is null)
+            {
+                return IpcConvertImageResponse.FromErrorCode(MediaConverterErrorCode.InvalidIpcRequestArgument);
+            }
+
+            var traceId = request.TraceId ?? Guid.NewGuid().ToString();
+
+            var workingFolder = request.WorkingFolder;
+            if (string.IsNullOrEmpty(workingFolder))
+            {
+                workingFolder = Path.Join(WorkingFolder, traceId);
+            }
+
+            Directory.CreateDirectory(workingFolder);
+
+            ipcHandlerLogger.LogMessage($"[{traceId}] Receive RequestConvertImage. InputFile='{request.InputFile}' OutputFile='{request.OutputFile}' ConvertConfigurationFile='{request.ConvertConfigurationFile}' WorkingFolder='{workingFolder}'");
+
+            var convertHandler = new ConvertHandler()
+            {
+                InputFile = request.InputFile,
+                OutputFile = request.OutputFile,
+                ConvertConfigurationFile = request.ConvertConfigurationFile,
+                WorkingFolder = workingFolder,
+                ShouldLogToConsole = ShouldLogToConsole,
+                ShouldLogToFile = ShouldLogToFile,
+            };
+
+            var errorCode = await Program.RunAsync(convertHandler);
+            ipcHandlerLogger.LogMessage($"[{traceId}] RequestConvertImage completed. ErrorCode={errorCode.Code} Message={errorCode.Message}");
+            return IpcConvertImageResponse.FromErrorCode(errorCode);
+        });
+
+        jsonIpcDirectRoutedProvider.AddRequestHandler(IpcPaths.Exit, (IpcExitRequest request) =>
+        {
+            ipcHandlerLogger.LogMessage($"Request Exit. Code={request.ExitCode} Reason={request.Reason}");
+
+            Task.Run(async () =>
+            {
+                await Task.Delay(TimeSpan.FromSeconds(1));
+                exitTaskCompletionSource.SetResult(request.ExitCode);
+            });
+
+            return new IpcExitResponse()
+            {
+                Code = MediaConverterErrorCode.Success.Code,
+                Message = MediaConverterErrorCode.Success.Message
+            };
+        });
+
+        jsonIpcDirectRoutedProvider.StartServer();
+        return await exitTaskCompletionSource.Task;
+    }
+}
+
+file class IpcHandlerLogger
+{
+    public IpcHandlerLogger(IpcHandler ipcHandler)
+    {
+        _ipcHandler = ipcHandler;
+
+        CanLog = _ipcHandler.ShouldLogToConsole is true || _ipcHandler.ShouldLogToFile is true;
+
+        if (_ipcHandler.ShouldLogToFile is true)
+        {
+            var logFile = Path.Join(_ipcHandler.WorkingFolder, "Log.txt");
+            _logFile = new FileInfo(logFile);
+        }
+    }
+
+    private readonly FileInfo? _logFile;
+    private readonly IpcHandler _ipcHandler;
+    private readonly Lock _locker = new Lock();
+
+    private bool CanLog { get; }
+
+    public void LogMessage(string message)
+    {
+        if (!CanLog)
+        {
+            return;
+        }
+
+        if (_ipcHandler.ShouldLogToConsole is true)
+        {
+            Console.WriteLine(message);
+        }
+
+        if (_logFile is { } logFile)
+        {
+            var logMessage = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss,fff}] {message}";
+            lock (_locker)
+            {
+                File.AppendAllLines(logFile.FullName, [logMessage]);
+            }
+        }
+    }
+}

src/MediaConverters/MediaConverters.Tool/CommandLineHandlers/IpcHandlers/MediaConverterIpcLogger.cs

@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+
+using dotnetCampus.Ipc.Utils.Logging;
+
+namespace DotNetCampus.MediaConverters.CommandLineHandlers;
+
+class MediaConverterIpcLogger : IpcLogger
+{
+    public MediaConverterIpcLogger(string name, IpcHandler ipcHandler) : base(name)
+    {
+        _ipcHandler = ipcHandler;
+        if (_ipcHandler.ShouldLogToFile is true)
+        {
+            var ipcLogFile = Path.Join(_ipcHandler.WorkingFolder, "IpcLog.log");
+            _logFile = new FileInfo(ipcLogFile);
+        }
+    }
+
+    private readonly IpcHandler _ipcHandler;
+
+    private bool ShouldLogToConsole => _ipcHandler.ShouldLogToConsole ?? false;
+    private readonly FileInfo? _logFile;
+
+    protected override bool IsEnabled(LogLevel logLevel)
+    {
+        if (!ShouldLogToConsole && _logFile is null)
+        {
+            // 没有任何日志输出
+            return false;
+        }
+
+        return base.IsEnabled(logLevel);
+    }
+
+    protected override void Log<TState>(LogLevel logLevel, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        if (!IsEnabled(logLevel))
+        {
+            return;
+        }
+
+        var message = formatter(state, exception);
+        if (ShouldLogToConsole)
+        {
+            Console.WriteLine($"[IPC] {message}");
+        }
+        if (_logFile is { } logFile)
+        {
+            var logMessage = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss,fff}][{logLevel}] {message}";
+            lock (logFile)
+            {
+                File.AppendAllLines(logFile.FullName, [logMessage]);
+            }
+        }
+    }
+}

src/MediaConverters/MediaConverters.Tool/MediaConverters.Tool.csproj

@@ -21,6 +21,7 @@
 
   <ItemGroup>
     <PackageReference Include="DotNetCampus.CommandLine" Version="4.0.0-alpha05" />
+    <PackageReference Include="dotnetCampus.Ipc" Version="2.0.0-alpha422" />
     <PackageReference Include="VC-LTL" Version="5.2.2" />
   </ItemGroup>
 

src/MediaConverters/MediaConverters.Tool/Program.cs

@@ -57,6 +57,7 @@ static async Task<int> Main(string[] args)
 
         return await DotNetCampus.Cli.CommandLine.Parse(args)
                 .AddHandler<ConvertHandler>()
+                .AddHandler<IpcHandler>()
                 .RunAsync()
             ;
     }