455 lines
20 KiB
C#
455 lines
20 KiB
C#
using System;
|
|
using System.IO;
|
|
using Unity.Pipeline.Commands;
|
|
using Unity.Pipeline.Compilation;
|
|
using Unity.Pipeline.CodeReload;
|
|
using Unity.Pipeline.Models;
|
|
using UnityEngine;
|
|
|
|
namespace Unity.Pipeline.Runtime.Commands
|
|
{
|
|
/// <summary>
|
|
/// CLI commands for code reload operations: apply [CodeReload] edits from a source file, inspect
|
|
/// the registry, and clean up saved reload assemblies.
|
|
/// </summary>
|
|
static class CodeReloadCommands
|
|
{
|
|
[CliCommand("reload_file", "Compile and apply in-place [CodeReload] edits from a source file", MainThreadRequired = true, Tags = new[] { "scripts/codereload" })]
|
|
public static CodeReloadResponse ReloadFile(
|
|
[CliArg("filename", "Source file containing [CodeReload] methods (e.g. Assets/Scripts/Player.cs)", Required = true)] string filename,
|
|
[CliArg("timeout", "Compilation timeout in milliseconds")] int timeout = 30000,
|
|
[CliArg("assemblyDir", "Directory to save compiled assemblies to disk (optional, default is in-memory only)")] string assemblyDir = null,
|
|
[CliArg("pdb", "Emit debug symbols (portable PDB) mapped to the original source so breakpoints bind in your editor. Compiles unoptimized.")] bool pdb = false)
|
|
{
|
|
return ReloadFileCore("reload_file", filename, timeout, assemblyDir, pdb, useInterpreter: false);
|
|
}
|
|
|
|
[CliCommand("reload_file_editor_interpreter", "Compile in-place [CodeReload] edits and run them through the IlInterpreter VM in this process instead of Assembly.Load (IL2CPP-safe; only a minimal host API + the target type are available)", MainThreadRequired = true, Tags = new[] { "scripts/codereload" })]
|
|
public static CodeReloadResponse ReloadFileEditorInterpreter(
|
|
[CliArg("filename", "Source file containing [CodeReload] methods (e.g. Assets/Scripts/Player.cs)", Required = true)] string filename,
|
|
[CliArg("timeout", "Compilation timeout in milliseconds")] int timeout = 30000,
|
|
[CliArg("assemblyDir", "Directory to save compiled assemblies to disk (optional, default is in-memory only)")] string assemblyDir = null,
|
|
[CliArg("pdb", "Emit debug symbols (portable PDB) mapped to the original source so breakpoints bind in your editor. Compiles unoptimized.")] bool pdb = false)
|
|
{
|
|
return ReloadFileCore("reload_file_editor_interpreter", filename, timeout, assemblyDir, pdb, useInterpreter: true);
|
|
}
|
|
|
|
/// <summary>Shared body of <c>reload_file</c> and <c>reload_file_editor_interpreter</c>:
|
|
/// the two commands differ only in the backend the reloaded methods run on.</summary>
|
|
private static CodeReloadResponse ReloadFileCore(string commandName, string filename, int timeout, string assemblyDir, bool pdb, bool useInterpreter)
|
|
{
|
|
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
|
|
|
|
try
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filename))
|
|
{
|
|
stopwatch.Stop();
|
|
return CodeReloadResponse.CmdFailure(
|
|
"Bad Request",
|
|
"Filename parameter is required and cannot be empty",
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (!filename.EndsWith(".cs", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
filename += ".cs";
|
|
}
|
|
|
|
var fullPath = ResolveSourceFilePath(filename);
|
|
if (string.IsNullOrEmpty(fullPath))
|
|
{
|
|
stopwatch.Stop();
|
|
return CodeReloadResponse.CmdFailure(
|
|
"File Not Found",
|
|
$"Could not locate source file: {filename}",
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
|
|
// In a Player build, the file must be inside the project's build-baked roots. The
|
|
// project layout cannot be resolved from a running build, so this is skipped in the
|
|
// editor (which resolves files against the live project).
|
|
if (!Application.isEditor)
|
|
{
|
|
var scopeCheck = ValidateReloadPath(fullPath, CodeReloadRegistry.AllowedReloadRoots);
|
|
if (!scopeCheck.IsValid)
|
|
{
|
|
stopwatch.Stop();
|
|
return CodeReloadResponse.CmdFailure(
|
|
scopeCheck.Error,
|
|
scopeCheck.ErrorDetails,
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
|
|
Debug.Log($"CodeReload: Executing {commandName} command: {fullPath}, timeout: {timeout}ms, assemblyDir: {assemblyDir ?? "in-memory"}, pdb: {pdb}, interpreter: {useInterpreter}");
|
|
|
|
var task = InPlaceReloadProcessor.ProcessSourceFileAsync(fullPath, assemblyDir, pdb, useInterpreter);
|
|
task.Wait();
|
|
var result = task.Result;
|
|
|
|
stopwatch.Stop();
|
|
|
|
if (result.Success)
|
|
{
|
|
// Everything matches the compiled baseline: an honest no-op success, not
|
|
// "reload successful with 0 methods" against a null assembly name. Reverting
|
|
// stale overrides (the edit was undone) is part of the outcome — say so
|
|
// instead of unregistering silently.
|
|
if (result.AllUpToDate)
|
|
{
|
|
var upToDate = CodeReloadResponse.CmdSuccess(
|
|
string.Empty,
|
|
$"Up to date: all {result.UpToDateMethods.Count} [CodeReload] method(s) match the compiled baseline — nothing reloaded" +
|
|
(result.RevertedMethods.Count > 0
|
|
? $"; reverted {result.RevertedMethods.Count} stale override(s): {string.Join(", ", result.RevertedMethods)}"
|
|
: "") + ".",
|
|
result.RegisteredMethods,
|
|
stopwatch.ElapsedMilliseconds);
|
|
upToDate.Diagnostics = result.CompilationDiagnostics;
|
|
return upToDate;
|
|
}
|
|
|
|
// "Compiled OK but bound nothing" is a failed reload in practice: the compile
|
|
// succeeded but every method was skipped downstream (e.g. an interpreter-unsupported
|
|
// construct, or no RuntimePipelineDriver registered the target). Surface the
|
|
// reasons from CompilationDiagnostics as a failure instead of a silent success.
|
|
if (result.RegisteredMethods.Count == 0 && result.ExtractedMethods.Count > 0)
|
|
{
|
|
var details = result.CompilationDiagnostics != null && result.CompilationDiagnostics.Count > 0
|
|
? "Compiled, but no methods were applied:\n- " + string.Join("\n- ", result.CompilationDiagnostics)
|
|
: "Compiled, but no methods were applied. Is the target component in the scene " +
|
|
"and in play mode (with the runtime Pipeline driver active)?";
|
|
return CodeReloadResponse.CmdFailure(
|
|
"No Methods Applied",
|
|
details,
|
|
stopwatch.ElapsedMilliseconds,
|
|
result.CompilationDiagnostics);
|
|
}
|
|
|
|
CodeReloadRegistry.InvokeReloadCallbacks(result.RegisteredMethods);
|
|
|
|
var response = CodeReloadResponse.CmdSuccess(
|
|
result.AssemblyName,
|
|
$"In-place code reload successful: {result.AssemblyName} with {result.RegisteredMethods.Count} methods" +
|
|
(result.RevertedMethods.Count > 0
|
|
? $"; reverted {result.RevertedMethods.Count} stale override(s): {string.Join(", ", result.RevertedMethods)}"
|
|
: ""),
|
|
result.RegisteredMethods,
|
|
stopwatch.ElapsedMilliseconds);
|
|
// Surface partial-skip reasons (some methods bound, others skipped) on success too.
|
|
response.Diagnostics = result.CompilationDiagnostics;
|
|
return response;
|
|
}
|
|
|
|
return CodeReloadResponse.CmdFailure(
|
|
"In-Place Reload Failed",
|
|
result.ErrorMessage ?? "In-place code reload processing failed",
|
|
stopwatch.ElapsedMilliseconds,
|
|
result.CompilationDiagnostics);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
stopwatch.Stop();
|
|
Debug.LogError($"CodeReload: {commandName} command failed: {ex.Message}");
|
|
Debug.LogError($"CodeReload: Stack trace: {ex.StackTrace}");
|
|
|
|
return CodeReloadResponse.CmdFailure(
|
|
"Execution Failed",
|
|
ex.ToString(),
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
|
|
[CliCommand("cleanup_codereload", "Remove old code reload DLL versions and clear registry", MainThreadRequired = true, RuntimeOnly = true, Tags = new[] { "scripts/codereload" })]
|
|
public static CodeReloadResponse CleanupCodeReload(
|
|
[CliArg("assemblyDir", "Directory containing assemblies to cleanup", Required = true)] string assemblyDir,
|
|
[CliArg("force_domain_reload", "Force Unity domain reload after cleanup")] bool forceDomainReload = true)
|
|
{
|
|
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
|
|
|
|
try
|
|
{
|
|
Debug.Log($"CodeReload: Executing cleanup_codereload command for directory: {assemblyDir}");
|
|
|
|
// Execute cleanup
|
|
var cleanupResult = CodeReloadCompiler.CleanupCodeReloadDlls(assemblyDir);
|
|
|
|
stopwatch.Stop();
|
|
|
|
if (cleanupResult.Success)
|
|
{
|
|
var message = $"Cleanup successful: {cleanupResult.Message}";
|
|
if (cleanupResult.DeletedFiles.Count > 0)
|
|
{
|
|
message += $" Files removed: {string.Join(", ", cleanupResult.DeletedFiles)}";
|
|
}
|
|
|
|
// Force domain reload if requested (interrupts gameplay but ensures clean state)
|
|
if (forceDomainReload && Application.isEditor)
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.Log("CodeReload: Requesting Unity domain reload to clean memory state");
|
|
UnityEditor.EditorUtility.RequestScriptReload();
|
|
message += " Unity domain reload requested.";
|
|
#endif
|
|
}
|
|
|
|
Debug.Log($"CodeReload: cleanup_codereload completed successfully in {stopwatch.ElapsedMilliseconds}ms");
|
|
|
|
return CodeReloadResponse.CmdSuccess(
|
|
"cleanup_completed",
|
|
message,
|
|
cleanupResult.DeletedFiles,
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
else
|
|
{
|
|
return CodeReloadResponse.CmdFailure(
|
|
"Cleanup Failed",
|
|
cleanupResult.Message,
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
stopwatch.Stop();
|
|
Debug.LogError($"CodeReload: cleanup_codereload command failed: {ex.Message}");
|
|
|
|
return CodeReloadResponse.CmdFailure(
|
|
"Execution Failed",
|
|
ex.ToString(),
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
|
|
[CliCommand("codereload_status", "Show current code reload registry status and statistics", MainThreadRequired = true, RuntimeOnly = true, Tags = new[] { "scripts/codereload" })]
|
|
public static CodeReloadResponse CodeReloadStatus()
|
|
{
|
|
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
|
|
|
|
try
|
|
{
|
|
// Get current registry stats
|
|
var stats = CodeReloadRegistry.GetStats();
|
|
|
|
stopwatch.Stop();
|
|
|
|
var statusMessage = $"Code Reload Status - " +
|
|
$"Reloadable Methods: {stats.ReloadableMethodCount}, " +
|
|
$"Active Overrides: {stats.ActiveOverrideCount}, " +
|
|
$"Loaded Types: {stats.LoadedTypeCount}";
|
|
|
|
Debug.Log($"CodeReload: {statusMessage}");
|
|
|
|
return CodeReloadResponse.CmdSuccess(
|
|
"status_retrieved",
|
|
statusMessage,
|
|
stats.ActiveOverrideIds,
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
stopwatch.Stop();
|
|
Debug.LogError($"CodeReload: codereload_status command failed: {ex.Message}");
|
|
|
|
return CodeReloadResponse.CmdFailure(
|
|
"Execution Failed",
|
|
ex.ToString(),
|
|
stopwatch.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validate that a resolved file path lives inside one of the allowed project roots and
|
|
/// exists on disk. "In scope" means under the Assets folder or a loaded package's location.
|
|
/// The path is normalized (collapsing any <c>..</c> segments) before the scope check, so a
|
|
/// path that escapes the allowed roots via traversal is rejected. A null or empty root set
|
|
/// matches nothing, so the path is rejected as out of scope. This is a security boundary —
|
|
/// it prevents files outside the project from being compiled and injected into the assembly.
|
|
/// </summary>
|
|
public static PathValidationResult ValidateReloadPath(string resolvedPath, System.Collections.Generic.IReadOnlyCollection<string> allowedRoots)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(resolvedPath))
|
|
{
|
|
return PathValidationResult.Invalid("Bad Request", "Resolved file path is empty.");
|
|
}
|
|
|
|
string fullPath;
|
|
try
|
|
{
|
|
fullPath = Path.GetFullPath(resolvedPath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return PathValidationResult.Invalid("Bad Request", $"Invalid path: {ex.Message}");
|
|
}
|
|
|
|
var underAnyRoot = false;
|
|
if (allowedRoots != null)
|
|
{
|
|
foreach (var root in allowedRoots)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(root))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string fullRoot;
|
|
try
|
|
{
|
|
fullRoot = Path.GetFullPath(root);
|
|
}
|
|
catch
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (IsUnderDirectory(fullPath, fullRoot))
|
|
{
|
|
underAnyRoot = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!underAnyRoot)
|
|
{
|
|
return PathValidationResult.Invalid(
|
|
"Out Of Project Scope",
|
|
$"Code reload only accepts files inside the project's baked roots (Assets/ or a loaded " +
|
|
$"package). '{fullPath}' is outside the project scope and will not be compiled.");
|
|
}
|
|
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return PathValidationResult.Invalid("File Not Found", $"Source file not found: {fullPath}");
|
|
}
|
|
|
|
return PathValidationResult.Valid();
|
|
}
|
|
|
|
/// <summary>
|
|
/// True when <paramref name="path"/> is contained within <paramref name="directory"/>.
|
|
/// Both are expected to be normalized absolute paths. A trailing separator is appended to
|
|
/// the directory so that a sibling such as "AssetsExtra" is not treated as being under "Assets".
|
|
/// </summary>
|
|
private static bool IsUnderDirectory(string path, string directory)
|
|
{
|
|
var prefix = directory.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
|
|
+ Path.DirectorySeparatorChar;
|
|
|
|
// Windows file systems are case-insensitive; Unix file systems are case-sensitive.
|
|
var comparison = Path.DirectorySeparatorChar == '\\'
|
|
? StringComparison.OrdinalIgnoreCase
|
|
: StringComparison.Ordinal;
|
|
|
|
return path.StartsWith(prefix, comparison);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resolve source file path from various possible locations.
|
|
/// </summary>
|
|
private static string ResolveSourceFilePath(string filename)
|
|
{
|
|
if (Path.IsPathRooted(filename) && File.Exists(filename))
|
|
{
|
|
return filename;
|
|
}
|
|
|
|
var potentialPaths = new[]
|
|
{
|
|
Path.Combine("Assets", filename),
|
|
Path.Combine("Assets", "Scripts", filename),
|
|
filename // Project root
|
|
};
|
|
|
|
foreach (var path in potentialPaths)
|
|
{
|
|
if (File.Exists(path))
|
|
{
|
|
return Path.GetFullPath(path);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Response model for code reload CLI commands.
|
|
/// Provides consistent response format for all code reload operations.
|
|
/// </summary>
|
|
class CodeReloadResponse : CommandExecutionResponse
|
|
{
|
|
/// <summary>
|
|
/// Assembly name or operation identifier for successful operations.
|
|
/// </summary>
|
|
public string AssemblyName { get; set; }
|
|
|
|
/// <summary>
|
|
/// List of registered method IDs or files processed.
|
|
/// </summary>
|
|
public System.Collections.Generic.List<string> Items { get; set; } = new System.Collections.Generic.List<string>();
|
|
|
|
/// <summary>
|
|
/// Compilation or processing diagnostics.
|
|
/// </summary>
|
|
public System.Collections.Generic.List<string> Diagnostics { get; set; } = new System.Collections.Generic.List<string>();
|
|
|
|
/// <summary>
|
|
/// Create a successful code reload response.
|
|
/// </summary>
|
|
public static CodeReloadResponse CmdSuccess(string assemblyName, string message, System.Collections.Generic.List<string> items, long executionTimeMs)
|
|
{
|
|
return new CodeReloadResponse
|
|
{
|
|
Success = true,
|
|
AssemblyName = assemblyName,
|
|
Message = message,
|
|
Items = items ?? new System.Collections.Generic.List<string>(),
|
|
ExecutionTimeMs = executionTimeMs,
|
|
ExecutedAt = DateTime.UtcNow
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a failed code reload response.
|
|
/// </summary>
|
|
public static CodeReloadResponse CmdFailure(string error, string errorDetails, long executionTimeMs, System.Collections.Generic.List<string> diagnostics = null)
|
|
{
|
|
return new CodeReloadResponse
|
|
{
|
|
Success = false,
|
|
Error = error,
|
|
ErrorDetails = errorDetails,
|
|
ExecutionTimeMs = executionTimeMs,
|
|
Diagnostics = diagnostics ?? new System.Collections.Generic.List<string>(),
|
|
ExecutedAt = DateTime.UtcNow
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Result of validating a code reload source path. <see cref="Error"/> is a short category and
|
|
/// <see cref="ErrorDetails"/> the human-readable explanation, matching the shape consumed by
|
|
/// <see cref="CodeReloadResponse.CmdFailure"/>.
|
|
/// </summary>
|
|
class PathValidationResult
|
|
{
|
|
public bool IsValid { get; private set; }
|
|
public string Error { get; private set; }
|
|
public string ErrorDetails { get; private set; }
|
|
|
|
public static PathValidationResult Valid()
|
|
{
|
|
return new PathValidationResult { IsValid = true };
|
|
}
|
|
|
|
public static PathValidationResult Invalid(string error, string errorDetails)
|
|
{
|
|
return new PathValidationResult { IsValid = false, Error = error, ErrorDetails = errorDetails };
|
|
}
|
|
}
|
|
} |