619 lines
25 KiB
C#
619 lines
25 KiB
C#
using System.Diagnostics;
|
|
using System.Text.Json.Nodes;
|
|
using AcDream.Launcher.Core.Integrity;
|
|
using AcDream.Launcher.Core.Installation;
|
|
using AcDream.Launcher.Core.Launching;
|
|
using AcDream.Launcher.Core.Profiles;
|
|
using AcDream.Platform;
|
|
|
|
namespace AcDream.Launcher.Core.Tests.Installation;
|
|
|
|
public sealed class LauncherInstallerTests : IDisposable
|
|
{
|
|
private readonly string _root = Path.Combine(
|
|
Path.GetTempPath(),
|
|
"acdream-installer-tests",
|
|
Guid.NewGuid().ToString("N"));
|
|
private readonly ApplicationPathSet _paths;
|
|
private readonly string _dats;
|
|
private readonly string _bakeExecutable;
|
|
|
|
public LauncherInstallerTests()
|
|
{
|
|
_paths = new ApplicationPathSet(
|
|
Path.Combine(_root, "config"),
|
|
Path.Combine(_root, "data"),
|
|
Path.Combine(_root, "cache"),
|
|
null);
|
|
_dats = Path.Combine(_root, "retail-dats");
|
|
_bakeExecutable = Path.Combine(_root, "bin", "acdream-bake");
|
|
CreateCompleteDatDirectory(_dats);
|
|
Directory.CreateDirectory(Path.GetDirectoryName(_bakeExecutable)!);
|
|
File.WriteAllText(_bakeExecutable, "fake executable marker");
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (Directory.Exists(_root))
|
|
{
|
|
Directory.Delete(_root, recursive: true);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FakeChildProgressPublishesVerifiedRecordAndFeedsExactSessionContent()
|
|
{
|
|
BakeProcessRequest? observedRequest = null;
|
|
var runner = new FakeBakeProcessRunner(async (request, output, _) =>
|
|
{
|
|
observedRequest = request;
|
|
Directory.CreateDirectory(Path.GetDirectoryName(request.OutputPath)!);
|
|
await File.WriteAllTextAsync(request.OutputPath, "complete prepared package");
|
|
long bytes = new FileInfo(request.OutputPath).Length;
|
|
output("acdream-bake human header\n{\"v\":1,\"e\":\"star");
|
|
output("ted\",\"bakeToolVersion\":4,\"outputPath\":\"pak\"}\n");
|
|
output("{\"v\":1,\"e\":\"progress\",\"phase\":\"mesh\","
|
|
+ "\"completed\":25,\"total\":100,\"failures\":0,"
|
|
+ "\"elapsedSeconds\":5,\"etaSeconds\":15}\n");
|
|
output("{\"v\":1,\"e\":\"newMetric\",\"value\":1}\n");
|
|
output($"{{\"v\":1,\"e\":\"completed\",\"bakeToolVersion\":4,"
|
|
+ $"\"outputBytes\":{bytes},\"failures\":0}}\n");
|
|
return new BakeProcessResult(0, string.Empty);
|
|
});
|
|
var installer = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
processRunner: runner);
|
|
var progress = new List<LauncherInstallProgress>();
|
|
|
|
LauncherInstallResult result = await installer.InstallAsync(
|
|
_dats,
|
|
threads: 7,
|
|
new ImmediateProgress<LauncherInstallProgress>(progress.Add));
|
|
|
|
Assert.NotNull(observedRequest);
|
|
Assert.Equal(Path.GetFullPath(_bakeExecutable), observedRequest.ExecutablePath);
|
|
Assert.Equal(Path.GetFullPath(_dats), observedRequest.DatDirectory);
|
|
Assert.Equal(
|
|
Path.Combine(_paths.DataDirectory, "pak", "acdream.pak"),
|
|
observedRequest.OutputPath);
|
|
Assert.Equal(
|
|
[
|
|
"--dat-dir", Path.GetFullPath(_dats),
|
|
"--out", Path.Combine(_paths.DataDirectory, "pak", "acdream.pak"),
|
|
"--threads", "7",
|
|
"--progress-json",
|
|
],
|
|
observedRequest.Arguments);
|
|
Assert.Equal(LauncherInstallRecordStore.CurrentBakeToolVersion,
|
|
result.Record.BakeToolVersion);
|
|
Assert.Equal(new FileInfo(result.Record.PreparedAssetPath).Length,
|
|
result.Record.PreparedAssetSize);
|
|
Assert.Equal(
|
|
await FileIntegrity.ComputeSha256HexAsync(result.Record.PreparedAssetPath),
|
|
result.Record.PreparedAssetSha256);
|
|
Assert.Contains(progress, value => value.Phase == LauncherInstallPhase.BakingMeshes);
|
|
Assert.Equal(LauncherInstallPhase.Completed, progress[^1].Phase);
|
|
|
|
var store = new LauncherInstallRecordStore(_paths);
|
|
InstallRecordVerification verification = await store.LoadAndVerifyAsync();
|
|
Assert.True(verification.IsVerified);
|
|
Assert.Equal(result.Record, verification.Record);
|
|
|
|
var server = new ServerProfile
|
|
{
|
|
Name = "Local ACE",
|
|
Host = "127.0.0.1",
|
|
Port = 9000,
|
|
};
|
|
var account = new AccountProfile
|
|
{
|
|
Account = "testaccount",
|
|
Password = "credential-never-serialized",
|
|
};
|
|
var character = new CharacterProfile
|
|
{
|
|
Name = "+Acdream",
|
|
Id = "0x5000000A",
|
|
LaunchMode = LaunchMode.Gui,
|
|
};
|
|
ComposedSessionConfig composed = SessionConfigComposer.Compose(
|
|
server,
|
|
account,
|
|
character,
|
|
result.Record,
|
|
_paths,
|
|
"installed-session");
|
|
JsonObject content = JsonNode.Parse(
|
|
SessionConfigComposer.Serialize(composed.Document))!
|
|
["process"]!["content"]!.AsObject();
|
|
Assert.Equal(result.Record.DatDirectory, (string?)content["datDirectory"]);
|
|
Assert.Equal(
|
|
result.Record.PreparedAssetPath,
|
|
(string?)content["preparedAssetPath"]);
|
|
Assert.DoesNotContain(
|
|
result.Record.PreparedAssetSha256,
|
|
SessionConfigComposer.Serialize(composed.Document),
|
|
StringComparison.Ordinal);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FailedChildRestoresPriorVerifiedPakAndRecord()
|
|
{
|
|
(LauncherInstaller installer, LauncherInstallRecordStore store, LauncherInstallRecord old) =
|
|
await CreateInstallerWithPriorRecordAsync(
|
|
async (request, output, _) =>
|
|
{
|
|
await File.WriteAllTextAsync(request.OutputPath, "partial replacement");
|
|
output("{\"v\":1,\"e\":\"started\",\"bakeToolVersion\":4}\n");
|
|
output("{\"v\":1,\"e\":\"error\",\"message\":\"fixture failed\"}\n");
|
|
return new BakeProcessResult(9, "human failure detail");
|
|
},
|
|
loadExisting: false);
|
|
string recordBefore = await File.ReadAllTextAsync(store.RecordPath);
|
|
var progress = new List<LauncherInstallProgress>();
|
|
|
|
LauncherInstallException exception = await Assert.ThrowsAsync<LauncherInstallException>(
|
|
() => installer.InstallAsync(
|
|
_dats,
|
|
2,
|
|
new ImmediateProgress<LauncherInstallProgress>(progress.Add)));
|
|
|
|
Assert.Contains("fixture failed", exception.Message, StringComparison.Ordinal);
|
|
Assert.Equal("previous verified package", await File.ReadAllTextAsync(
|
|
store.PreparedAssetPath));
|
|
Assert.Equal(recordBefore, await File.ReadAllTextAsync(store.RecordPath));
|
|
InstallRecordVerification verification = await store.LoadAndVerifyAsync();
|
|
Assert.True(verification.IsVerified);
|
|
Assert.Equal(old, verification.Record);
|
|
Assert.Equal(LauncherInstallPhase.Failed, progress[^1].Phase);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ContradictoryTerminalCannotReplaceFirstFailureOrPriorInstall()
|
|
{
|
|
(LauncherInstaller installer, LauncherInstallRecordStore store, LauncherInstallRecord old) =
|
|
await CreateInstallerWithPriorRecordAsync(
|
|
async (request, output, _) =>
|
|
{
|
|
await File.WriteAllTextAsync(request.OutputPath, "contradictory output");
|
|
long bytes = new FileInfo(request.OutputPath).Length;
|
|
output("{\"v\":1,\"e\":\"started\",\"bakeToolVersion\":4}\n");
|
|
output("{\"v\":1,\"e\":\"error\",\"message\":\"first failure\"}\n");
|
|
output($"{{\"v\":1,\"e\":\"completed\",\"bakeToolVersion\":4,"
|
|
+ $"\"outputBytes\":{bytes},\"failures\":0}}\n");
|
|
return new BakeProcessResult(0, string.Empty);
|
|
});
|
|
|
|
LauncherInstallException exception =
|
|
await Assert.ThrowsAsync<LauncherInstallException>(
|
|
() => installer.InstallAsync(_dats, 2));
|
|
|
|
Assert.Contains("after", exception.Message, StringComparison.OrdinalIgnoreCase);
|
|
Assert.Equal(
|
|
"previous verified package",
|
|
await File.ReadAllTextAsync(store.PreparedAssetPath));
|
|
Assert.Equal(old, (await store.LoadAndVerifyAsync()).Record);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CancellationRestoresPriorInstallAndNeverPublishesPartialOutput()
|
|
{
|
|
var enteredChild = new TaskCompletionSource(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
(LauncherInstaller installer, LauncherInstallRecordStore store, LauncherInstallRecord old) =
|
|
await CreateInstallerWithPriorRecordAsync(
|
|
async (request, _, cancellationToken) =>
|
|
{
|
|
await File.WriteAllTextAsync(
|
|
request.OutputPath,
|
|
"partial replacement",
|
|
cancellationToken);
|
|
enteredChild.SetResult();
|
|
await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken);
|
|
return new BakeProcessResult(0, string.Empty);
|
|
});
|
|
var progress = new List<LauncherInstallProgress>();
|
|
using var cancellation = new CancellationTokenSource();
|
|
|
|
Task<LauncherInstallResult> operation = installer.InstallAsync(
|
|
_dats,
|
|
3,
|
|
new ImmediateProgress<LauncherInstallProgress>(progress.Add),
|
|
cancellation.Token);
|
|
await enteredChild.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
cancellation.Cancel();
|
|
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => operation);
|
|
Assert.Equal("previous verified package", await File.ReadAllTextAsync(
|
|
store.PreparedAssetPath));
|
|
Assert.False(File.Exists(LauncherInstallRecordStore.GetBackupPath(
|
|
store.PreparedAssetPath)));
|
|
InstallRecordVerification verification = await store.LoadAndVerifyAsync();
|
|
Assert.True(verification.IsVerified);
|
|
Assert.Equal(old, verification.Record);
|
|
Assert.Equal(LauncherInstallPhase.Cancelled, progress[^1].Phase);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FailedFirstInstallRemovesPartialPakAndCreatesNoRecord()
|
|
{
|
|
var runner = new FakeBakeProcessRunner(async (request, _, _) =>
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(request.OutputPath)!);
|
|
await File.WriteAllTextAsync(request.OutputPath, "partial");
|
|
return new BakeProcessResult(1, "failed");
|
|
});
|
|
var installer = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
processRunner: runner);
|
|
var store = new LauncherInstallRecordStore(_paths);
|
|
|
|
await Assert.ThrowsAsync<LauncherInstallException>(
|
|
() => installer.InstallAsync(_dats, 1));
|
|
|
|
Assert.False(File.Exists(store.PreparedAssetPath));
|
|
Assert.False(File.Exists(store.RecordPath));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CancellationDuringHashRemovesUnrecordedPublishedPackage()
|
|
{
|
|
var hashEntered = new TaskCompletionSource(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var runner = new FakeBakeProcessRunner(async (request, output, _) =>
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(request.OutputPath)!);
|
|
await File.WriteAllTextAsync(request.OutputPath, "complete but unverified");
|
|
long bytes = new FileInfo(request.OutputPath).Length;
|
|
output("{\"v\":1,\"e\":\"started\",\"bakeToolVersion\":4}\n");
|
|
output($"{{\"v\":1,\"e\":\"completed\",\"bakeToolVersion\":4,"
|
|
+ $"\"outputBytes\":{bytes},\"failures\":0}}\n");
|
|
return new BakeProcessResult(0, string.Empty);
|
|
});
|
|
var store = new LauncherInstallRecordStore(_paths);
|
|
var installer = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
recordStore: store,
|
|
processRunner: runner,
|
|
computeSha256: async (_, cancellationToken) =>
|
|
{
|
|
hashEntered.SetResult();
|
|
await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken);
|
|
return new string('a', 64);
|
|
});
|
|
using var cancellation = new CancellationTokenSource();
|
|
|
|
Task<LauncherInstallResult> operation = installer.InstallAsync(
|
|
_dats,
|
|
2,
|
|
cancellationToken: cancellation.Token);
|
|
await hashEntered.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
cancellation.Cancel();
|
|
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => operation);
|
|
Assert.False(File.Exists(store.PreparedAssetPath));
|
|
Assert.False(File.Exists(store.RecordPath));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task IndependentInstallersSerializeAndWaitingCancellationTouchesNothing()
|
|
{
|
|
var storeA = new LauncherInstallRecordStore(_paths);
|
|
LauncherInstallRecord old = await CreatePriorRecordAsync(storeA);
|
|
string backupPath = LauncherInstallRecordStore.GetBackupPath(
|
|
storeA.PreparedAssetPath);
|
|
var childEntered = new TaskCompletionSource(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var releaseChild = new TaskCompletionSource(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var runnerA = new FakeBakeProcessRunner(async (request, _, _) =>
|
|
{
|
|
await File.WriteAllTextAsync(request.OutputPath, "installer A in progress");
|
|
childEntered.SetResult();
|
|
await releaseChild.Task;
|
|
return new BakeProcessResult(1, "fixture A failed");
|
|
});
|
|
bool runnerBEntered = false;
|
|
var runnerB = new FakeBakeProcessRunner((_, _, _) =>
|
|
{
|
|
runnerBEntered = true;
|
|
return Task.FromResult(new BakeProcessResult(1, "must not run"));
|
|
});
|
|
var installerA = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
recordStore: storeA,
|
|
processRunner: runnerA);
|
|
var installerB = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
recordStore: new LauncherInstallRecordStore(_paths),
|
|
processRunner: runnerB);
|
|
|
|
Task<LauncherInstallResult> operationA =
|
|
installerA.InstallAsync(_dats, 1);
|
|
await childEntered.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
try
|
|
{
|
|
using var cancellationB = new CancellationTokenSource();
|
|
Task<LauncherInstallResult> operationB = installerB.InstallAsync(
|
|
_dats,
|
|
1,
|
|
cancellationToken: cancellationB.Token);
|
|
await Task.Delay(150);
|
|
cancellationB.Cancel();
|
|
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => operationB);
|
|
Assert.False(runnerBEntered);
|
|
Assert.Equal(
|
|
"installer A in progress",
|
|
await File.ReadAllTextAsync(storeA.PreparedAssetPath));
|
|
Assert.Equal(
|
|
"previous verified package",
|
|
await File.ReadAllTextAsync(backupPath));
|
|
}
|
|
finally
|
|
{
|
|
releaseChild.TrySetResult();
|
|
}
|
|
|
|
await Assert.ThrowsAsync<LauncherInstallException>(() => operationA);
|
|
Assert.Equal(
|
|
"previous verified package",
|
|
await File.ReadAllTextAsync(storeA.PreparedAssetPath));
|
|
Assert.False(File.Exists(backupPath));
|
|
Assert.Equal(old, (await storeA.LoadAndVerifyAsync()).Record);
|
|
}
|
|
|
|
[Fact]
|
|
public void StagingCleanupDeletesOnlyExactBakeTransactionNames()
|
|
{
|
|
var store = new LauncherInstallRecordStore(_paths);
|
|
string outputPath = store.PreparedAssetPath;
|
|
string directory = Path.GetDirectoryName(outputPath)!;
|
|
Directory.CreateDirectory(directory);
|
|
string owned = BakeOutputStagingContract.CreateStagingPath(
|
|
outputPath,
|
|
Guid.Parse("01234567-89ab-cdef-0123-456789abcdef"));
|
|
string canonical = outputPath;
|
|
string backup = LauncherInstallRecordStore.GetBackupPath(outputPath);
|
|
string oldPattern = Path.Combine(
|
|
directory,
|
|
$".{Path.GetFileName(outputPath)}.{Guid.NewGuid():N}.tmp");
|
|
string invalidTransaction = Path.Combine(
|
|
directory,
|
|
$".{Path.GetFileName(outputPath)}.acdream-bake.not-a-guid.tmp");
|
|
string unrelated = Path.Combine(directory, "unrelated.tmp");
|
|
Assert.Equal(
|
|
Path.Combine(
|
|
directory,
|
|
".acdream.pak.acdream-bake.0123456789abcdef0123456789abcdef.tmp"),
|
|
owned);
|
|
foreach (string path in new[]
|
|
{
|
|
owned,
|
|
canonical,
|
|
backup,
|
|
oldPattern,
|
|
invalidTransaction,
|
|
unrelated,
|
|
})
|
|
{
|
|
File.WriteAllText(path, Path.GetFileName(path));
|
|
}
|
|
|
|
BakeOutputStagingContract.DeleteOwnedStagingFiles(outputPath);
|
|
|
|
Assert.False(File.Exists(owned));
|
|
Assert.True(File.Exists(canonical));
|
|
Assert.True(File.Exists(backup));
|
|
Assert.True(File.Exists(oldPattern));
|
|
Assert.True(File.Exists(invalidTransaction));
|
|
Assert.True(File.Exists(unrelated));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task KilledProcessReleasesLeaseAndRestartReclaimsOnlyBakeStaging()
|
|
{
|
|
var store = new LauncherInstallRecordStore(_paths);
|
|
LauncherInstallRecord old = await CreatePriorRecordAsync(store);
|
|
string staging = BakeOutputStagingContract.CreateStagingPath(
|
|
store.PreparedAssetPath,
|
|
Guid.Parse("fedcba98-7654-3210-fedc-ba9876543210"));
|
|
string ready = Path.Combine(_root, "fixture-ready");
|
|
string fixtureDll = GetInstallLeaseFixturePath();
|
|
Assert.True(File.Exists(fixtureDll), $"Missing fixture: {fixtureDll}");
|
|
|
|
var startInfo = new ProcessStartInfo("dotnet")
|
|
{
|
|
RedirectStandardError = true,
|
|
RedirectStandardOutput = true,
|
|
UseShellExecute = false,
|
|
};
|
|
startInfo.ArgumentList.Add(fixtureDll);
|
|
startInfo.ArgumentList.Add(
|
|
InstallerTransactionLease.GetLockPath(store.DataDirectory));
|
|
startInfo.ArgumentList.Add(staging);
|
|
startInfo.ArgumentList.Add(ready);
|
|
using Process helper = Process.Start(startInfo)
|
|
?? throw new InvalidOperationException("Could not start lease fixture.");
|
|
try
|
|
{
|
|
await WaitForFileAsync(ready, helper, TimeSpan.FromSeconds(10));
|
|
Assert.True(File.Exists(staging));
|
|
|
|
var blockedInstaller = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
recordStore: new LauncherInstallRecordStore(_paths));
|
|
using var blockedCancellation = new CancellationTokenSource(
|
|
TimeSpan.FromMilliseconds(200));
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(
|
|
() => blockedInstaller.LoadExistingAsync(blockedCancellation.Token));
|
|
Assert.True(File.Exists(staging));
|
|
}
|
|
finally
|
|
{
|
|
if (!helper.HasExited)
|
|
{
|
|
helper.Kill(entireProcessTree: true);
|
|
}
|
|
|
|
await helper.WaitForExitAsync().WaitAsync(TimeSpan.FromSeconds(10));
|
|
}
|
|
|
|
var restarted = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
recordStore: new LauncherInstallRecordStore(_paths));
|
|
InstallRecordVerification recovered = await restarted.LoadExistingAsync();
|
|
|
|
Assert.True(recovered.IsVerified);
|
|
Assert.Equal(old, recovered.Record);
|
|
Assert.False(File.Exists(staging));
|
|
Assert.Equal(
|
|
"previous verified package",
|
|
await File.ReadAllTextAsync(store.PreparedAssetPath));
|
|
}
|
|
|
|
private async Task<(
|
|
LauncherInstaller Installer,
|
|
LauncherInstallRecordStore Store,
|
|
LauncherInstallRecord Old)> CreateInstallerWithPriorRecordAsync(
|
|
Func<BakeProcessRequest, Action<string>, CancellationToken, Task<BakeProcessResult>> handler,
|
|
bool loadExisting = true)
|
|
{
|
|
var store = new LauncherInstallRecordStore(_paths);
|
|
Directory.CreateDirectory(Path.GetDirectoryName(store.PreparedAssetPath)!);
|
|
await File.WriteAllTextAsync(
|
|
store.PreparedAssetPath,
|
|
"previous verified package");
|
|
var old = new LauncherInstallRecord(
|
|
Path.GetFullPath(_dats),
|
|
Path.GetFullPath(store.PreparedAssetPath),
|
|
await FileIntegrity.ComputeSha256HexAsync(store.PreparedAssetPath),
|
|
new FileInfo(store.PreparedAssetPath).Length,
|
|
LauncherInstallRecordStore.CurrentBakeToolVersion);
|
|
await store.SaveAtomicallyAsync(old);
|
|
|
|
var installer = new LauncherInstaller(
|
|
_paths,
|
|
_bakeExecutable,
|
|
recordStore: store,
|
|
processRunner: new FakeBakeProcessRunner(handler));
|
|
if (loadExisting)
|
|
{
|
|
Assert.True((await installer.LoadExistingAsync()).IsVerified);
|
|
}
|
|
|
|
return (installer, store, old);
|
|
}
|
|
|
|
private async Task<LauncherInstallRecord> CreatePriorRecordAsync(
|
|
LauncherInstallRecordStore store)
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(store.PreparedAssetPath)!);
|
|
await File.WriteAllTextAsync(
|
|
store.PreparedAssetPath,
|
|
"previous verified package");
|
|
var old = new LauncherInstallRecord(
|
|
Path.GetFullPath(_dats),
|
|
Path.GetFullPath(store.PreparedAssetPath),
|
|
await FileIntegrity.ComputeSha256HexAsync(store.PreparedAssetPath),
|
|
new FileInfo(store.PreparedAssetPath).Length,
|
|
LauncherInstallRecordStore.CurrentBakeToolVersion);
|
|
await store.SaveAtomicallyAsync(old);
|
|
return old;
|
|
}
|
|
|
|
private static async Task WaitForFileAsync(
|
|
string path,
|
|
Process process,
|
|
TimeSpan timeout)
|
|
{
|
|
using var cancellation = new CancellationTokenSource(timeout);
|
|
while (!File.Exists(path))
|
|
{
|
|
if (process.HasExited)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"Lease fixture exited with {process.ExitCode}: "
|
|
+ await process.StandardError.ReadToEndAsync());
|
|
}
|
|
|
|
await Task.Delay(25, cancellation.Token);
|
|
}
|
|
}
|
|
|
|
private static string GetInstallLeaseFixturePath()
|
|
{
|
|
string root = FindRepositoryRoot();
|
|
string configuration = new DirectoryInfo(AppContext.BaseDirectory)
|
|
.Parent?.Name
|
|
?? "Release";
|
|
return Path.Combine(
|
|
root,
|
|
"tests",
|
|
"AcDream.Launcher.Core.Tests.Fixtures.InstallLeaseHolder",
|
|
"bin",
|
|
configuration,
|
|
"net10.0",
|
|
"AcDream.Launcher.Core.Tests.Fixtures.InstallLeaseHolder.dll");
|
|
}
|
|
|
|
private static string FindRepositoryRoot()
|
|
{
|
|
foreach (string start in new[]
|
|
{
|
|
AppContext.BaseDirectory,
|
|
Environment.CurrentDirectory,
|
|
})
|
|
{
|
|
for (var directory = new DirectoryInfo(start);
|
|
directory is not null;
|
|
directory = directory.Parent)
|
|
{
|
|
if (File.Exists(Path.Combine(directory.FullName, "AcDream.slnx")))
|
|
{
|
|
return directory.FullName;
|
|
}
|
|
}
|
|
}
|
|
|
|
throw new DirectoryNotFoundException("Could not locate repository root.");
|
|
}
|
|
|
|
private static void CreateCompleteDatDirectory(string directory)
|
|
{
|
|
Directory.CreateDirectory(directory);
|
|
foreach (string fileName in DatDirectoryLocator.RequiredFileNames)
|
|
{
|
|
File.WriteAllText(Path.Combine(directory, fileName), "fixture");
|
|
}
|
|
}
|
|
|
|
private sealed class FakeBakeProcessRunner(
|
|
Func<BakeProcessRequest, Action<string>, CancellationToken, Task<BakeProcessResult>> handler)
|
|
: IBakeProcessRunner
|
|
{
|
|
private readonly Func<
|
|
BakeProcessRequest,
|
|
Action<string>,
|
|
CancellationToken,
|
|
Task<BakeProcessResult>> _handler = handler;
|
|
|
|
public Task<BakeProcessResult> RunAsync(
|
|
BakeProcessRequest request,
|
|
Action<string> onStandardOutput,
|
|
CancellationToken cancellationToken = default) =>
|
|
_handler(request, onStandardOutput, cancellationToken);
|
|
}
|
|
|
|
private sealed class ImmediateProgress<T>(Action<T> callback) : IProgress<T>
|
|
{
|
|
public void Report(T value) => callback(value);
|
|
}
|
|
}
|