Merge pull request #69 from guitarrapc/guitarrapc-patch-1

[BREAKING CHANGE] feat: Rename Settings to DefaultSettings, error handling.

Author: guitarrapc

src/UnityBuildRunner.Core/BuildErrorCode.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Reflection;
+
+namespace UnityBuildRunner.Core;
+
+internal enum BuildErrorCode
+{
+    [ErrorExitCode(0)]
+    Success,
+    [ErrorExitCode(9901)]
+    ProcessNull,
+    [ErrorExitCode(9902)]
+    ProcessImmediatelyExit,
+    [ErrorExitCode(9903)]
+    ProcessTimeout,
+}
+
+[AttributeUsage(AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+internal sealed class ErrorExitCodeAttribute : Attribute
+{
+    public int ExitCode { get; }
+    public ErrorExitCodeAttribute(int exitCode) => ExitCode = exitCode;
+}
+
+internal static class EnumExtensions
+{
+    /// <summary>
+    /// Obtain T Attribute from Enum
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="e"></param>
+    /// <returns></returns>
+    public static T? GetAttrubute<T>(this Enum e) where T : Attribute
+    {
+        var field = e.GetType().GetField(e.ToString());
+        if (field is not null && field.GetCustomAttribute<T>() is T att)
+        {
+            return att;
+        }
+        return null;
+    }
+}

src/UnityBuildRunner.Core/Builder.cs

@@ -40,24 +40,14 @@ public DefaultBuilder(ILogger logger, IErrorFilter errorFilter)
 
     public async Task<int> BuildAsync(ISettings settings, TimeSpan timeout)
     {
-        logger.LogInformation($"Preparing Unity Build.");
-
-        // validate
-        if (string.IsNullOrWhiteSpace(settings.UnityPath))
-            throw new ArgumentException($"Please pass Unity Executable path with argument `--unity-path` or environment variable `{nameof(settings.UnityPath)}`.");
-        if (!File.Exists(settings.UnityPath))
-            throw new FileNotFoundException($"{nameof(settings.UnityPath)} not found.{settings.UnityPath}");
-        if (string.IsNullOrEmpty(settings.LogFilePath))
-            throw new ArgumentException("Missing '-logFile filename' argument. Make sure you had targeted any log file path.");
-
         // Initialize
         logger.LogInformation($"Initializing LogFilePath '{settings.LogFilePath}'.");
         await InitializeAsync(settings.LogFilePath);
 
         // Build
         logger.LogInformation("Starting Unity Build.");
-        logger.LogInformation($"Command: {settings.UnityPath} {settings.ArgumentString}");
-        logger.LogInformation($"WorkingDir: {settings.WorkingDirectory}");
+        logger.LogInformation($"  - Command: {settings.UnityPath} {settings.ArgumentString}");
+        logger.LogInformation($"  - WorkingDir: {settings.WorkingDirectory}");
         var sw = Stopwatch.StartNew();
         using var process = Process.Start(new ProcessStartInfo()
         {
@@ -68,9 +58,12 @@ public async Task<int> BuildAsync(ISettings settings, TimeSpan timeout)
             CreateNoWindow = true,
         });
 
+        var exitCode = BuildErrorCode.Success;
+
         if (process is null)
         {
             sw.Stop();
+            exitCode = BuildErrorCode.ProcessNull;
             throw new OperationCanceledException("Could not start Unity. Somthing blocked creating process.");
         }
 
@@ -86,13 +79,15 @@ public async Task<int> BuildAsync(ISettings settings, TimeSpan timeout)
                 }
                 else
                 {
+                    exitCode = BuildErrorCode.ProcessTimeout;
                     throw new TimeoutException($"Unity Process has been aborted. Waited 10 seconds but could't create logFilePath '{settings.LogFilePath}'.");
                 }
             }
 
             // log file generated but process immediately exited.
             if (process.HasExited)
             {
+                exitCode = BuildErrorCode.ProcessImmediatelyExit;
                 throw new OperationCanceledException($"Unity process started but build unexpectedly finished before began.");
             }
 
@@ -104,6 +99,7 @@ public async Task<int> BuildAsync(ISettings settings, TimeSpan timeout)
                 {
                     if (sw.Elapsed.TotalMilliseconds > timeout.TotalMilliseconds)
                     {
+                        exitCode = BuildErrorCode.ProcessTimeout;
                         throw new TimeoutException($"Timeout exceeded. {timeout.TotalMinutes}min has been passed, stopping build.");
                     }
 
@@ -124,46 +120,55 @@ public async Task<int> BuildAsync(ISettings settings, TimeSpan timeout)
         {
             sw.Stop();
 
-            if (process.ExitCode == 0)
+            if (exitCode is BuildErrorCode.Success)
             {
-                logger.LogInformation($"Unity Build successfully complete. ({process.ExitCode})");
+                logger.LogInformation($"Unity Build successfully complete.");
             }
             else
             {
-                logger.LogInformation($"Unity Build failed. ({process.ExitCode})");
+                logger.LogInformation($"Unity Build failed.");
             }
 
             logger.LogInformation($"Elapsed Time {sw.Elapsed}");
 
             // Assume exit Unity process
-            if (!process.HasExited)
+            if (process is not null && !process.HasExited)
             {
                 logger.LogInformation($"Killing unterminated process. ({process.Id})");
                 process.Kill(true);
             }
         }
-        return process.ExitCode;
+
+        return exitCode.GetAttrubute<ErrorExitCodeAttribute>()?.ExitCode ?? 0;
     }
 
-    public async Task InitializeAsync(string path)
+    public async Task InitializeAsync(string logFilePath)
     {
-        if (!File.Exists(path))
+        await AssumeLogFileInitialized(logFilePath).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Assume Logfile is not exists, or delete before run.
+    /// </summary>
+    /// <param name="logFilePath"></param>
+    /// <returns></returns>
+    public async Task AssumeLogFileInitialized(string logFilePath)
+    {
+        if (!File.Exists(logFilePath))
         {
             return;
         }
-
-        // retry 10 times
-        var retry = 10;
+        var retry = 10; // retry 10 times
         for (var i = 1; i <= retry; i++)
         {
             try
             {
-                File.Delete(path);
+                File.Delete(logFilePath);
                 break;
             }
             catch (IOException) when (i < retry + 1)
             {
-                logger.LogWarning($"Couldn't delete file {path}, retrying... ({i + 1}/{retry})");
+                logger.LogWarning($"Couldn't delete file {logFilePath}, retrying... ({i + 1}/{retry})");
                 await Task.Delay(TimeSpan.FromSeconds(1));
                 continue;
             }

src/UnityBuildRunner.Core/DefaultSettings.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+
+namespace UnityBuildRunner.Core;
+
+public interface ISettings
+{
+    string[] Args { get; }
+    string ArgumentString { get; }
+    string UnityPath { get; }
+    string LogFilePath { get; }
+    string WorkingDirectory { get; }
+}
+
+public record DefaultSettings(string[] Args, string ArgumentString, string UnityPath, string LogFilePath, string WorkingDirectory) : ISettings
+{
+    /// <summary>
+    /// Validate Settings is correct.
+    /// </summary>
+    public void Validate()
+    {
+        // validate
+        if (string.IsNullOrWhiteSpace(UnityPath))
+            throw new ArgumentException($"Please pass Unity Executable path with argument '--unity-path' or environment variable '{nameof(UnityPath)}'.");
+        if (string.IsNullOrEmpty(LogFilePath))
+            throw new ArgumentException("Missing '-logFile filename' argument. Make sure you had targeted any log file path.");
+        if (!File.Exists(UnityPath))
+            throw new FileNotFoundException($"{nameof(UnityPath)} not found. {UnityPath}");
+    }
+
+    /// <summary>
+    /// Parse args and generate Settings.
+    /// </summary>
+    public static bool TryParse(string[] args, string unityPath, [NotNullWhen(true)] out DefaultSettings? settings)
+    {
+        try
+        {
+            settings = Parse(args, unityPath);
+            return true;
+        }
+        catch (Exception)
+        {
+            settings = null;
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Parse args and generate Settings.
+    /// </summary>
+    public static DefaultSettings Parse(string[] args, string unityPath)
+    {
+        // Unity Path
+        var unityPathFixed = !string.IsNullOrWhiteSpace(unityPath) ? unityPath : Environment.GetEnvironmentVariable(nameof(UnityPath)) ?? throw new ArgumentNullException("Unity Path not specified. Please specify via argument or Environment Variable.");
+
+        var logFilePath = GetLogFile(args);
+        // fallback logfilePath
+        if (string.IsNullOrWhiteSpace(logFilePath))
+        {
+            logFilePath = "unitybuild.log";
+            args = args.Concat(new[] { "-logFile", logFilePath }).ToArray();
+        }
+
+        var arguments = args.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
+        var argumentString = string.Join(" ", arguments.Select(s => s.First() == '-' ? s : "\"" + s + "\""));
+
+        // WorkingDirectory should be cli launch path.
+        var workingDirectory = Directory.GetCurrentDirectory();
+
+        // Create settings and validate
+        var settings = new DefaultSettings(arguments, argumentString, unityPathFixed, logFilePath, workingDirectory);
+        settings.Validate();
+
+        return settings;
+    }
+
+    internal static string GetLogFile(string[] args)
+    {
+        var logFile = "";
+        for (var i = 0; i < args.Length; i++)
+        {
+            if (string.Equals(args[i], "-logFile", StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
+            {
+                logFile = args[i + 1];
+                break;
+            }
+        }
+        return logFile;
+    }
+}

src/UnityBuildRunner.Core/Settings.cs

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp6.0</TargetFrameworks>
-    <LangVersion>latest</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
 
     <Version>1.0.0</Version>
@@ -20,9 +20,15 @@
   </PropertyGroup>
 
   <ItemGroup>
-	<PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
-  </ItemGroup>
-
+	  <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>UnityBuildRunner.Core.Tests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+  
   <ItemGroup>
     <None Include="..\..\LICENSE.md">
       <Pack>True</Pack>

src/UnityBuildRunner.Core/UnityBuildRunner.Core.csproj

@@ -33,7 +33,7 @@ public async Task<int> Run([Option("--unity-path", "Full Path to the Unity.exe (
         if (arguments is not null && arguments.Any())
         {
             var builder = new DefaultBuilder(logger);
-            var settings = Settings.Parse(arguments.ToArray()!, unityPath);
+            var settings = DefaultSettings.Parse(arguments.ToArray()!, unityPath);
             var timeoutSpan = TimeSpan.TryParse(timeout, out var r) ? r : TimeSpan.FromMinutes(60);
 
             return await builder.BuildAsync(settings, timeoutSpan);