0b85bd5e8a
Every served install script (Windows/WinPE PowerShell 5.1, Linux and macOS bash) now looks at the device before acting: a healthy, current agent enrolled with this server is left alone (Already Installed), an older one is upgraded in place with its enrollment kept, a failed one (service missing, disabled, stopped or crash-looping, watchdog down, binary missing or broken, Windows Installer registration or cache gone) is restarted through the agent's own initialize and, if that does not help, reinstalled (MSI repair REINSTALL=ALL REINSTALLMODE=vamus, cache restored from the kept package, uninstall+install with ProgramData and the registry key set aside as a last resort; Linux/macOS move files in one by one and re-register the unit or daemon). The bootstrap token is used only when there is no usable credential or the agent points at another server, never printed, and masked out of failure messages. One setup at a time, leftovers of interrupted runs cleared. Each run ends with one outcome line and exits 1 on failure. The agent's status verb now prints a JSON line with version, server URL, credential state (valid/missing/unreadable/other-device) and whether a bootstrap token is pending, which the scripts read. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
738 lines
40 KiB
C#
738 lines
40 KiB
C#
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using Backend.Enrollment;
|
|
using Shared.Contracts.Models;
|
|
using Xunit;
|
|
|
|
namespace Backend.Tests;
|
|
|
|
/// <summary>
|
|
/// The served install scripts are safe to run any number of times: they parse (Windows
|
|
/// PowerShell 5.1, PowerShell 7, bash), decide from what is on the device between leaving
|
|
/// it alone, installing, upgrading, repairing and re-enrolling, and never print the token.
|
|
/// The decisions run the scripts' own functions against described device states; nothing
|
|
/// is installed.
|
|
/// </summary>
|
|
public partial class InstallScriptRepairTests
|
|
{
|
|
private const string Server = "https://control.example.com";
|
|
private const string Token = "s3cret-token.0f1e2d3c4b5a69788796a5b4c3d2e1f00f1e2d3c4b5a69788796a5b4c3d2e1f0";
|
|
private const string Fingerprint = "0f1e2d3c4b5a69788796a5b4c3d2e1f00f1e2d3c4b5a69788796a5b4c3d2e1f0";
|
|
|
|
public static TheoryData<string> WindowsVariants => ["msi", "msi-pinned", "zip", "quote"];
|
|
|
|
public static TheoryData<string> UnixVariants => ["linux", "linux-pinned", "osx", "osx-pinned", "quote"];
|
|
|
|
private static string WindowsScript(string variant) => variant switch
|
|
{
|
|
"msi" => InstallEndpoints.BuildWindowsScript(Server, Token, $"{Server}/msi?token=t", $"{Server}/zip?token=t", "1.5.0", "1.5.0", false, null),
|
|
"msi-pinned" => InstallEndpoints.BuildWindowsScript(Server, Token, $"{Server}/msi?token=t", $"{Server}/zip?token=t", "1.5.0", null, false, Fingerprint),
|
|
"zip" => InstallEndpoints.BuildWindowsScript(Server, Token, null, $"{Server}/zip?token=t", null, "1.5.0.3", true, null),
|
|
_ => InstallEndpoints.BuildWindowsScript(Server, "it's", $"{Server}/msi?token=t", $"{Server}/zip?token=t", null, null, false, null),
|
|
};
|
|
|
|
private static string UnixScript(string variant) => variant switch
|
|
{
|
|
"linux" => InstallEndpoints.BuildUnixScript(Server, Token, "linux", "token=t", false, null, "1.5.0", "1.5.0"),
|
|
"linux-pinned" => InstallEndpoints.BuildUnixScript(Server, Token, "linux", "token=t", false, Fingerprint, "1.5.0", null),
|
|
"osx" => InstallEndpoints.BuildUnixScript(Server, Token, "osx", "token=t", true, null, null, "1.5.0"),
|
|
"osx-pinned" => InstallEndpoints.BuildUnixScript(Server, Token, "osx", "token=t", false, Fingerprint, "1.5.0", "1.5.0"),
|
|
_ => InstallEndpoints.BuildUnixScript(Server, "it's", "linux", "token=t", false, null, null, null),
|
|
};
|
|
|
|
[Theory]
|
|
[MemberData(nameof(WindowsVariants))]
|
|
public async Task WindowsScriptsParseInWindowsPowerShellAndPowerShell7(string variant)
|
|
{
|
|
var shells = new[] { WindowsPowerShell(), Pwsh() }.OfType<string>().ToList();
|
|
Assert.SkipWhen(shells.Count == 0, "Needs Windows PowerShell or pwsh.");
|
|
var check = """
|
|
$tokens = $null; $errors = $null
|
|
[void][System.Management.Automation.Language.Parser]::ParseInput([IO.File]::ReadAllText($args[0]), [ref]$tokens, [ref]$errors)
|
|
$errors | ForEach-Object { $_.Message + ' (line ' + $_.Extent.StartLineNumber + ')' }
|
|
exit $errors.Count
|
|
""";
|
|
using var folder = new ScratchFolder();
|
|
var script = folder.Write("install.ps1", WindowsScript(variant));
|
|
var checker = folder.Write("check.ps1", check);
|
|
foreach (var shell in shells)
|
|
{
|
|
var (code, output, _) = await RunAsync(shell, $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -File \"{checker}\" \"{script}\"");
|
|
Assert.True(code == 0, $"{Path.GetFileName(shell)}: {output}");
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData(nameof(UnixVariants))]
|
|
public async Task UnixScriptsPassBashSyntaxCheck(string variant)
|
|
{
|
|
var bash = Bash();
|
|
Assert.SkipWhen(bash is null, "Needs bash (Git Bash on Windows).");
|
|
using var folder = new ScratchFolder();
|
|
var script = folder.Write("install.sh", UnixScript(variant));
|
|
var (code, output, _) = await RunAsync(bash!, $"-n \"{ForBash(script)}\"");
|
|
Assert.True(code == 0, output);
|
|
Assert.DoesNotContain("\r", UnixScript(variant));
|
|
}
|
|
|
|
[Fact]
|
|
public void TheTokenAndServerAreQuotedForEachShell()
|
|
{
|
|
Assert.Contains("$token = 'it''s'", WindowsScript("quote"));
|
|
Assert.Contains("token='it'\\''s'", UnixScript("quote"));
|
|
Assert.Equal("'a''b'", InstallEndpoints.PsQuote("a'b"));
|
|
Assert.Equal("'a'\\''b'", InstallEndpoints.ShQuote("a'b"));
|
|
}
|
|
|
|
[Fact]
|
|
public void TheServedVersionIsEmbeddedForTheComparison()
|
|
{
|
|
var msi = WindowsScript("msi");
|
|
Assert.Contains("$msiVersion = '1.5.0'", msi);
|
|
Assert.Contains("$portableOnly = $false", msi);
|
|
var zip = WindowsScript("zip");
|
|
Assert.Contains("$msiUrl = ''", zip);
|
|
Assert.Contains("$zipVersion = '1.5.0.3'", zip);
|
|
Assert.Contains("$portableOnly = $true", zip);
|
|
var osx = UnixScript("osx");
|
|
Assert.Contains("x64) target='' ;;", osx);
|
|
Assert.Contains("*) target='1.5.0' ;;", osx);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("1.4.0", "1.4.0")]
|
|
[InlineData(" 1.4.0.7+1a2b3c4 ", "1.4.0.7+1a2b3c4")]
|
|
[InlineData("2026.10.23.1400", "2026.10.23.1400")]
|
|
[InlineData("0.0.0.0", null)]
|
|
[InlineData("1.4", null)]
|
|
[InlineData("1.4.0'; rm -rf /", null)]
|
|
[InlineData(null, null)]
|
|
public void OnlyAVersionTheComparisonUnderstandsGoesIntoAScript(string? version, string? expected)
|
|
=> Assert.Equal(expected, InstallEndpoints.ScriptSafeVersion(version));
|
|
|
|
[Theory]
|
|
[MemberData(nameof(WindowsVariants))]
|
|
public void TheWindowsTokenIsOnlyEverHandedToWindowsInstallerOrTheRegistry(string variant)
|
|
{
|
|
// Allowed: the assignment, masking it out of an error, msiexec's (hidden) property,
|
|
// the registry value the agent reads, and comparing it with a pending one.
|
|
string[] allowed =
|
|
[
|
|
@"^\$token = '",
|
|
@"^if \(\$token -and \$Text\) \{ return \$Text\.Replace\(\$token, '<token>'\) \}$",
|
|
@"^if \(\$Enroll\) \{ \$arguments \+= ""BOOTSTRAPTOKEN=\$token"" \}$",
|
|
@"Set-ItemProperty -Path \$executerKey -Name 'BootstrapToken' -Value \$token( \})?$",
|
|
@"^\$state\.TokenIsOurs = \[bool\]\(\$pending -and \$pending -ceq \$token\)$",
|
|
];
|
|
var script = WindowsScript(variant);
|
|
foreach (var line in Lines(script).Where(l => TokenVariable().IsMatch(l)))
|
|
{
|
|
Assert.True(allowed.Any(pattern => Regex.IsMatch(line, pattern)), $"unexpected use of $token: {line}");
|
|
}
|
|
|
|
if (variant != "quote")
|
|
{
|
|
Assert.Single(Lines(script), l => l.Contains(Token, StringComparison.Ordinal));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData(nameof(UnixVariants))]
|
|
public void TheUnixTokenIsOnlyEverHandedToTheAgentsConfiguration(string variant)
|
|
{
|
|
string[] allowed =
|
|
[
|
|
@"^token='",
|
|
@"^""\$exe"" configure --url ""\$server"" --token ""\$token"" >/dev/null$",
|
|
@"^if \[ ""\$pending"" = ""\$token"" \]; then pending_ours=1; fi$",
|
|
];
|
|
var script = UnixScript(variant);
|
|
foreach (var line in Lines(script).Where(l => TokenVariable().IsMatch(l)))
|
|
{
|
|
Assert.True(allowed.Any(pattern => Regex.IsMatch(line, pattern)), $"unexpected use of $token: {line}");
|
|
}
|
|
|
|
if (variant != "quote")
|
|
{
|
|
Assert.Single(Lines(script), l => l.Contains(Token, StringComparison.Ordinal));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData(nameof(WindowsVariants))]
|
|
public void WindowsScriptsEndWithOneOutcomeAndExitNonZeroOnFailure(string variant)
|
|
{
|
|
var script = WindowsScript(variant);
|
|
foreach (var outcome in new[] { "'Already Installed: ExecuteR Agent '", "{ 'Installed' }", "{ 'Upgraded' }", "{ 'Repaired' }", "('Failed: ' + $reason)" })
|
|
{
|
|
Assert.Contains(outcome, script);
|
|
}
|
|
|
|
Assert.Contains("if ($launchedForThis) { exit 1 }", script);
|
|
Assert.EndsWith("}", script.TrimEnd());
|
|
// Interrupted runs: one setup at a time, leftovers cleared, a kept enrollment put back.
|
|
Assert.Contains(@"'Global\ExecuteRAgentSetup'", script);
|
|
Assert.Contains("Clear-ExecuteRLeftovers", script);
|
|
Assert.Contains(@"'Global\_MSIExecute'", script);
|
|
Assert.Contains("Restore-ExecuteRKept", script);
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData(nameof(UnixVariants))]
|
|
public void UnixScriptsRunEverythingFromTheLastLine(string variant)
|
|
{
|
|
var script = UnixScript(variant);
|
|
Assert.Equal("main", Lines(script).Last());
|
|
foreach (var outcome in new[] { "echo \"Already Installed: ExecuteR Agent", "outcome=Installed", "outcome=Upgraded", "outcome=Repaired", "echo \"Failed: $*\"" })
|
|
{
|
|
Assert.Contains(outcome, script);
|
|
}
|
|
|
|
Assert.Contains("mkdir \"$lock\"", script);
|
|
Assert.Contains("rm -rf \"$dest.staging\"", script);
|
|
}
|
|
|
|
/// <summary>A device state for the Windows plan: healthy, current (1.5.0), MSI, enrolled with this server.</summary>
|
|
private const string PsHealthy = """
|
|
@{ Present = $true; ExeExists = $true; ExeWorks = $true; Version = '1.5.0'; ServerUrl = 'https://control.example.com';
|
|
PolicyServerUrl = $null; Credential = 'valid'; TokenPending = $false; TokenIsOurs = $false; MsiMarker = $true;
|
|
Msi = @{ ProductCode = '{A}'; Version = '1.5.0.0'; CacheOk = $true };
|
|
Agent = @{ Exists = $true; Status = 'Running'; StartType = 'Automatic' };
|
|
Watchdog = @{ Exists = $true; Status = 'Running'; StartType = 'Automatic' }; WatchdogExpected = $true }
|
|
""";
|
|
|
|
private static readonly (string Name, string Changes, string Target, string Kind, string Action, bool Enroll, bool Pending)[] WindowsPlans =
|
|
{
|
|
// name, state changes, target, msi or zip script, expected action, enroll, enrollment pending
|
|
("healthy and current", "", "1.5.0", "msi", "None", false, false),
|
|
("healthy and newer than the server", "$s.Version = '1.6.0'", "1.5.0", "msi", "None", false, false),
|
|
("no package version known", "", "", "msi", "None", false, false),
|
|
("server with a trailing slash and other case", "$s.ServerUrl = 'HTTPS://Control.Example.com/'", "1.5.0", "msi", "None", false, false),
|
|
("nothing installed", "$s = @{ Present = $false }", "1.5.0", "msi", "Install", true, false),
|
|
("older", "$s.Version = '1.4.9'", "1.5.0", "msi", "Upgrade", false, false),
|
|
("a calendar-era build", "$s.Version = '2026.10.23.1400'", "1.5.0", "msi", "Upgrade", false, false),
|
|
("older and enrolled elsewhere", "$s.Version = '1.4.9'; $s.ServerUrl = 'https://old.example.com'", "1.5.0", "msi", "Upgrade", true, false),
|
|
("service stopped", "$s.Agent.Status = 'Stopped'", "1.5.0", "msi", "Repair", false, false),
|
|
("service disabled", "$s.Agent.StartType = 'Disabled'; $s.Agent.Status = 'Stopped'", "1.5.0", "msi", "Repair", false, false),
|
|
("service missing", "$s.Agent = @{ Exists = $false; Status = 'Missing'; StartType = 'Missing' }", "1.5.0", "msi", "Repair", false, false),
|
|
("watchdog stopped", "$s.Watchdog.Status = 'Stopped'", "1.5.0", "msi", "Repair", false, false),
|
|
("binary missing", "$s.ExeExists = $false; $s.ExeWorks = $false; $s.Version = $null", "1.5.0", "msi", "Repair", false, false),
|
|
("binary broken", "$s.ExeWorks = $false; $s.Version = $null", "1.5.0", "msi", "Repair", false, false),
|
|
("Windows Installer cache missing", "$s.Msi.CacheOk = $false", "1.5.0", "msi", "Repair", false, false),
|
|
("Windows Installer registration gone", "$s.Msi = $null", "1.5.0", "msi", "Repair", false, false),
|
|
("portable: no MSI is fine", "$s.Msi = $null; $s.MsiMarker = $false", "1.5.0", "zip", "None", false, false),
|
|
("enrolled elsewhere", "$s.ServerUrl = 'https://old.example.com'", "1.5.0", "msi", "Enroll", true, false),
|
|
("no server configured", "$s.ServerUrl = $null", "1.5.0", "msi", "Enroll", true, false),
|
|
("credential missing", "$s.Credential = 'missing'", "1.5.0", "msi", "Enroll", true, false),
|
|
("credential unreadable", "$s.Credential = 'unreadable'", "1.5.0", "msi", "Enroll", true, false),
|
|
("credential of other hardware", "$s.Credential = 'other-device'", "1.5.0", "msi", "Enroll", true, false),
|
|
("enrolling with this token already", "$s.Credential = 'missing'; $s.TokenPending = $true; $s.TokenIsOurs = $true", "1.5.0", "msi", "None", false, true),
|
|
("a pending token of another run", "$s.Credential = 'missing'; $s.TokenPending = $true", "1.5.0", "msi", "Enroll", true, false),
|
|
("stopped and without credential", "$s.Agent.Status = 'Stopped'; $s.Credential = 'missing'", "1.5.0", "msi", "Repair", true, false),
|
|
};
|
|
|
|
[Fact]
|
|
public async Task WindowsPlansFollowTheDeviceState()
|
|
{
|
|
var shell = WindowsPowerShell() ?? Pwsh();
|
|
Assert.SkipWhen(shell is null, "Needs Windows PowerShell or pwsh.");
|
|
var body = new StringBuilder("""
|
|
$server = 'https://control.example.com'
|
|
$token = 'tok'
|
|
$msiUrl = 'x'; $zipUrl = 'x'; $msiVersion = ''; $zipVersion = ''; $portableOnly = $false
|
|
|
|
""");
|
|
body.AppendLine(InstallScripts.WindowsFunctions);
|
|
var cases = WindowsPlans;
|
|
for (var i = 0; i < cases.Length; i++)
|
|
{
|
|
body.AppendLine($"$s = {PsHealthy}");
|
|
body.AppendLine(cases[i].Changes);
|
|
body.AppendLine($"$p = Get-ExecuteRPlan $s '{cases[i].Target}' ${(cases[i].Kind == "zip" ? "true" : "false")}");
|
|
body.AppendLine($"Write-Output ('{i}=' + $p.Action + '|' + $p.Enroll + '|' + $p.EnrollPending)");
|
|
}
|
|
|
|
using var folder = new ScratchFolder();
|
|
var script = folder.Write("plans.ps1", body.ToString());
|
|
var (code, output, _) = await RunAsync(shell!, $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -File \"{script}\"");
|
|
Assert.True(code == 0, output);
|
|
var results = Results(output);
|
|
for (var i = 0; i < cases.Length; i++)
|
|
{
|
|
var expected = $"{cases[i].Action}|{(cases[i].Enroll ? "True" : "False")}|{(cases[i].Pending ? "True" : "False")}";
|
|
Assert.True(results.TryGetValue(i.ToString(), out var actual) && actual == expected, $"{cases[i].Name}: expected {expected}, got {actual}\n{output}");
|
|
}
|
|
}
|
|
|
|
/// <summary>A device state for the unix plan: healthy, current (1.5.0), enrolled with this server.</summary>
|
|
private const string ShHealthy =
|
|
"present=1 works=1 version=1.5.0 configured=https://control.example.com credential=valid token_pending=0 pending_ours=0 "
|
|
+ "registered=1 agent_running=1 agent_disabled=0 watchdog_expected=1 watchdog_running=1";
|
|
|
|
private static readonly (string Name, string Changes, string Target, string Action, string Enroll, string Pending)[] UnixPlans =
|
|
{
|
|
// name, state changes, target, expected action, enroll, enrollment pending
|
|
("healthy and current", "", "1.5.0", "none", "0", "0"),
|
|
("healthy and newer than the server", "version=1.6.0", "1.5.0", "none", "0", "0"),
|
|
("no package version known", "", "", "none", "0", "0"),
|
|
("server with a trailing slash and other case", "configured=HTTPS://Control.Example.com/", "1.5.0", "none", "0", "0"),
|
|
("nothing installed", "present=0 works=0 registered=0 agent_running=0 watchdog_expected=0 watchdog_running=0", "1.5.0", "install", "1", "0"),
|
|
("older", "version=1.4.9", "1.5.0", "upgrade", "0", "0"),
|
|
("a calendar-era build", "version=2026.10.23.1400", "1.5.0", "upgrade", "0", "0"),
|
|
("older and enrolled elsewhere", "version=1.4.9 configured=https://old.example.com", "1.5.0", "upgrade", "1", "0"),
|
|
("service stopped", "agent_running=0", "1.5.0", "repair", "0", "0"),
|
|
("service disabled", "agent_running=0 agent_disabled=1", "1.5.0", "repair", "0", "0"),
|
|
("service not registered", "registered=0", "1.5.0", "repair", "0", "0"),
|
|
("watchdog stopped", "watchdog_running=0", "1.5.0", "repair", "0", "0"),
|
|
("binary broken", "works=0 version=", "1.5.0", "repair", "0", "0"),
|
|
("enrolled elsewhere", "configured=https://old.example.com", "1.5.0", "enroll", "1", "0"),
|
|
("no server configured", "configured=", "1.5.0", "enroll", "1", "0"),
|
|
("credential missing", "credential=missing", "1.5.0", "enroll", "1", "0"),
|
|
("credential of other hardware", "credential=other-device", "1.5.0", "enroll", "1", "0"),
|
|
("enrolling with this token already", "credential=missing token_pending=1 pending_ours=1", "1.5.0", "none", "0", "1"),
|
|
("a pending token of another run", "credential=missing token_pending=1", "1.5.0", "enroll", "1", "0"),
|
|
("stopped and without credential", "agent_running=0 credential=missing", "1.5.0", "repair", "1", "0"),
|
|
};
|
|
|
|
[Fact]
|
|
public async Task UnixPlansFollowTheDeviceState()
|
|
{
|
|
var bash = Bash();
|
|
Assert.SkipWhen(bash is null, "Needs bash (Git Bash on Windows).");
|
|
var body = new StringBuilder("""
|
|
set -euo pipefail
|
|
server='https://control.example.com'
|
|
token='tok'
|
|
os=linux arch=x64 pkg=x dest=/nonexistent/executer tmp=/nonexistent reported=0 locked=0 lock=/nonexistent/lock
|
|
|
|
""");
|
|
body.Append(InstallScripts.UnixFunctions.ReplaceLineEndings("\n")).Append('\n');
|
|
var cases = UnixPlans;
|
|
for (var i = 0; i < cases.Length; i++)
|
|
{
|
|
body.Append($"{ShHealthy}\n{cases[i].Changes}\ntarget='{cases[i].Target}'\nplan\necho \"{i}=$action|$enroll|$enroll_pending\"\n");
|
|
}
|
|
|
|
using var folder = new ScratchFolder();
|
|
var script = folder.Write("plans.sh", body.ToString());
|
|
var (code, output, _) = await RunAsync(bash!, $"\"{ForBash(script)}\"");
|
|
Assert.True(code == 0, output);
|
|
var results = Results(output);
|
|
for (var i = 0; i < cases.Length; i++)
|
|
{
|
|
var expected = $"{cases[i].Action}|{cases[i].Enroll}|{cases[i].Pending}";
|
|
Assert.True(results.TryGetValue(i.ToString(), out var actual) && actual == expected, $"{cases[i].Name}: expected {expected}, got {actual}\n{output}");
|
|
}
|
|
}
|
|
|
|
private static readonly (string Left, string Right)[] VersionPairs =
|
|
[
|
|
("1.5.0", "1.4.9"), ("1.4.9", "1.5.0"), ("1.5.0", "1.5.0.0"), ("1.5.0.1", "1.5.0"), ("1.5.0+abc", "1.5.0"),
|
|
("1.10.0", "1.9.0"), ("1.5.0", "2026.10.23.1400"), ("2026.10.23.1400", "2026.10.22.2359"), ("1.5.0", ""),
|
|
("", "1.5.0"), ("0.0.0.0", "1.0.0"), ("1.5", "1.5.0"), ("01.05.00", "1.5.0"), ("", ""), ("junk", "junk"),
|
|
];
|
|
|
|
[Fact]
|
|
public async Task WindowsVersionsCompareAsTheServerDoes()
|
|
{
|
|
var shell = WindowsPowerShell() ?? Pwsh();
|
|
Assert.SkipWhen(shell is null, "Needs Windows PowerShell or pwsh.");
|
|
var body = new StringBuilder("$server = 'x'; $token = 'x'\n").AppendLine(InstallScripts.WindowsFunctions);
|
|
for (var i = 0; i < VersionPairs.Length; i++)
|
|
{
|
|
body.AppendLine($"Write-Output ('{i}=' + (Compare-ExecuteRVersion '{VersionPairs[i].Left}' '{VersionPairs[i].Right}'))");
|
|
}
|
|
|
|
using var folder = new ScratchFolder();
|
|
var (code, output, _) = await RunAsync(shell!, $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -File \"{folder.Write("versions.ps1", body.ToString())}\"");
|
|
Assert.True(code == 0, output);
|
|
AssertVersionResults(Results(output), output);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UnixVersionsCompareAsTheServerDoes()
|
|
{
|
|
var bash = Bash();
|
|
Assert.SkipWhen(bash is null, "Needs bash (Git Bash on Windows).");
|
|
var body = new StringBuilder("set -euo pipefail\ndest=/nonexistent\n").Append(InstallScripts.UnixFunctions.ReplaceLineEndings("\n")).Append('\n');
|
|
for (var i = 0; i < VersionPairs.Length; i++)
|
|
{
|
|
body.Append($"echo \"{i}=$(version_compare '{VersionPairs[i].Left}' '{VersionPairs[i].Right}')\"\n");
|
|
}
|
|
|
|
using var folder = new ScratchFolder();
|
|
var (code, output, _) = await RunAsync(bash!, $"\"{ForBash(folder.Write("versions.sh", body.ToString()))}\"");
|
|
Assert.True(code == 0, output);
|
|
AssertVersionResults(Results(output), output);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A stand-in for executer-agent: version, status (the JSON line), configure and
|
|
/// initialize, keeping its state in files under FAKE_STATE and noting each call
|
|
/// (configure with a token as configure-token, never the token itself).
|
|
/// </summary>
|
|
private const string FakeUnixAgent = """
|
|
#!/usr/bin/env bash
|
|
here=$(cd "$(dirname "$0")" && pwd)
|
|
S="$FAKE_STATE"
|
|
enroll() { if [ -f "$S/token" ]; then echo valid > "$S/credential"; rm -f "$S/token"; fi; }
|
|
case "$1" in
|
|
version) echo version >> "$S/calls"; cat "$here/AGENT_VERSION" ;;
|
|
status)
|
|
echo status >> "$S/calls"
|
|
srv=null; if [ -f "$S/server" ]; then srv="\"$(cat "$S/server")\""; fi
|
|
cred=missing; if [ -f "$S/credential" ]; then cred=$(cat "$S/credential"); fi
|
|
pending=false; if [ -f "$S/token" ]; then pending=true; fi
|
|
echo "{\"service\":\"executer-agent\",\"installed\":true,\"state\":\"active\",\"version\":\"$(cat "$here/AGENT_VERSION")\",\"serverUrl\":$srv,\"credential\":\"$cred\",\"enrollmentId\":null,\"credentialExpiresUtc\":null,\"bootstrapTokenPending\":$pending}"
|
|
echo "Service 'ExecuteR Agent': active" ;;
|
|
configure)
|
|
shift
|
|
call=configure
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--url) printf '%s' "$2" > "$S/server"; shift 2 ;;
|
|
--token) printf '%s' "$2" > "$S/token"; call=configure-token; shift 2 ;;
|
|
*) shift ;;
|
|
esac
|
|
done
|
|
echo "$call" >> "$S/calls" ;;
|
|
initialize)
|
|
echo initialize >> "$S/calls"
|
|
if [ -f "$S/fail-initialize" ]; then echo 'cannot register the service' >&2; exit 3; fi
|
|
touch "$S/registered.agent" "$S/running.executer-agent" "$S/running.executer-watchdog"
|
|
enroll
|
|
echo 'systemd unit executer-agent installed.' ;;
|
|
esac
|
|
""";
|
|
|
|
/// <summary>The service manager and the package download, stood in for after the script's own functions.</summary>
|
|
private const string UnixOverrides = """
|
|
mac=0
|
|
sleep() { case "$1" in 0.*) command sleep "$1" ;; esac; }
|
|
download() { : > "$2"; }
|
|
unpack() { cp -R "$FAKE_PACKAGE/." "$2/"; }
|
|
svc_registered() { [ -f "$FAKE_STATE/registered.$1" ]; }
|
|
systemctl() {
|
|
local verb=$1 u
|
|
shift
|
|
if [ "${1:-}" = --quiet ]; then shift; fi
|
|
case "$verb" in
|
|
is-active) [ -f "$FAKE_STATE/running.$1" ] ;;
|
|
is-enabled) echo enabled ;;
|
|
stop) for u in "$@"; do rm -f "$FAKE_STATE/running.$u"; done ;;
|
|
restart)
|
|
touch "$FAKE_STATE/running.$1"
|
|
if [ -f "$FAKE_STATE/token" ]; then echo valid > "$FAKE_STATE/credential"; rm -f "$FAKE_STATE/token"; fi ;;
|
|
*) return 0 ;;
|
|
esac
|
|
}
|
|
""";
|
|
|
|
[Fact]
|
|
public async Task TheUnixScriptInstallsThenLeavesAloneRepairsUpgradesAndReEnrolls()
|
|
{
|
|
var bash = Bash();
|
|
Assert.SkipWhen(bash is null, "Needs bash (Git Bash on Windows).");
|
|
using var folder = new ScratchFolder();
|
|
var root = ForBash(folder.Path);
|
|
var state = Directory.CreateDirectory(Path.Combine(folder.Path, "state")).FullName;
|
|
var package = Directory.CreateDirectory(Path.Combine(folder.Path, "package")).FullName;
|
|
Directory.CreateDirectory(Path.Combine(folder.Path, "tmp"));
|
|
File.WriteAllText(Path.Combine(package, "executer-agent"), FakeUnixAgent.ReplaceLineEndings("\n"));
|
|
File.WriteAllText(Path.Combine(package, "executer-watchdog"), "#!/usr/bin/env bash\n");
|
|
File.WriteAllText(Path.Combine(package, "AGENT_VERSION"), "1.5.0\n");
|
|
var dest = Path.Combine(folder.Path, "opt", "agent");
|
|
var calls = Path.Combine(state, "calls");
|
|
|
|
async Task<(int Code, string Last, string[] Calls, string Output)> Run(string target)
|
|
{
|
|
var before = File.Exists(calls) ? File.ReadAllLines(calls).Length : 0;
|
|
var script = InstallEndpoints.BuildUnixScript(Server, Token, "linux", "token=t", false, null, target, target)
|
|
.Replace("if [ \"$(id -u)\" -ne 0 ]; then echo 'Failed: run with sudo/root.' >&2; exit 1; fi\n", "")
|
|
.Replace("dest=/opt/executer/agent\n", $"dest='{root}/opt/agent'\n")
|
|
.Replace("lock=/var/run/executer-install.lock\n", $"lock='{root}/lock'\n");
|
|
Assert.EndsWith("\nmain", script.TrimEnd());
|
|
script = script.TrimEnd()[..^"main".Length] + UnixOverrides.ReplaceLineEndings("\n") + "\nmain\n";
|
|
var (code, output, stdout) = await RunAsync(bash!, $"\"{ForBash(folder.Write("install.sh", script))}\"", new()
|
|
{
|
|
["FAKE_STATE"] = ForBash(state),
|
|
["FAKE_PACKAGE"] = ForBash(package),
|
|
["TMPDIR"] = $"{root}/tmp",
|
|
});
|
|
Assert.DoesNotContain(Token, output);
|
|
var all = File.Exists(calls) ? File.ReadAllLines(calls) : [];
|
|
return (code, Lines(stdout).Last(), all[before..], output);
|
|
}
|
|
|
|
// Nothing there: installed and enrolled with the token.
|
|
var run = await Run("1.5.0");
|
|
Assert.True(run.Code == 0, run.Output);
|
|
Assert.StartsWith("Installed: ExecuteR Agent 1.5.0 is running for https://control.example.com, enrolled", run.Last);
|
|
Assert.Contains("configure-token", run.Calls);
|
|
Assert.Contains("initialize", run.Calls);
|
|
|
|
// Again: nothing changes.
|
|
run = await Run("1.5.0");
|
|
Assert.Equal(0, run.Code);
|
|
Assert.StartsWith("Already Installed: ExecuteR Agent 1.5.0 is running", run.Last);
|
|
Assert.All(run.Calls, call => Assert.Contains(call, new[] { "version", "status" }));
|
|
|
|
// Interrupted earlier runs leave a staging folder and a temp folder: both go, nothing else changes.
|
|
Directory.CreateDirectory(dest + ".staging");
|
|
Directory.CreateDirectory(Path.Combine(folder.Path, "tmp", "executer-install.stale"));
|
|
run = await Run("1.5.0");
|
|
Assert.StartsWith("Already Installed:", run.Last);
|
|
Assert.False(Directory.Exists(dest + ".staging"));
|
|
Assert.False(Directory.Exists(Path.Combine(folder.Path, "tmp", "executer-install.stale")));
|
|
|
|
// The service stopped: started again, the enrollment kept (no token).
|
|
File.Delete(Path.Combine(state, "running.executer-agent"));
|
|
run = await Run("1.5.0");
|
|
Assert.StartsWith("Repaired: ExecuteR Agent 1.5.0 is running", run.Last);
|
|
Assert.Contains("initialize", run.Calls);
|
|
Assert.DoesNotContain("configure-token", run.Calls);
|
|
|
|
// A newer package: upgraded in place, the enrollment kept.
|
|
File.WriteAllText(Path.Combine(package, "AGENT_VERSION"), "1.6.0\n");
|
|
run = await Run("1.6.0");
|
|
Assert.StartsWith("Upgraded: ExecuteR Agent 1.6.0 is running", run.Last);
|
|
Assert.Equal("1.6.0", File.ReadAllText(Path.Combine(dest, "AGENT_VERSION")).Trim());
|
|
Assert.DoesNotContain("configure-token", run.Calls);
|
|
|
|
// Enrolled with another server: pointed here and enrolled with the token.
|
|
File.WriteAllText(Path.Combine(state, "server"), "https://old.example.com");
|
|
run = await Run("1.6.0");
|
|
Assert.StartsWith("Repaired:", run.Last);
|
|
Assert.Contains("configure-token", run.Calls);
|
|
Assert.Equal(Server, File.ReadAllText(Path.Combine(state, "server")));
|
|
|
|
// A binary that no longer runs: the files laid down again.
|
|
File.WriteAllText(Path.Combine(dest, "executer-agent"), "\u007fELF garbage");
|
|
run = await Run("1.6.0");
|
|
Assert.StartsWith("Repaired: ExecuteR Agent 1.6.0 is running", run.Last);
|
|
Assert.Equal(FakeUnixAgent.ReplaceLineEndings("\n"), File.ReadAllText(Path.Combine(dest, "executer-agent")).ReplaceLineEndings("\n"));
|
|
|
|
// A device where the service cannot be registered: one Failed line and a non-zero exit.
|
|
foreach (var file in Directory.GetFiles(state))
|
|
{
|
|
File.Delete(file);
|
|
}
|
|
|
|
Directory.Delete(dest, recursive: true);
|
|
File.WriteAllText(Path.Combine(state, "fail-initialize"), "");
|
|
run = await Run("1.6.0");
|
|
Assert.Equal(1, run.Code);
|
|
Assert.StartsWith("Failed: ", run.Last);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Everything of the Windows script that touches the machine (services, registry, Windows
|
|
/// Installer, files) replaced by a device kept in $F; the agent binary is Invoke-FakeAgent.
|
|
/// </summary>
|
|
private const string WindowsFakes = """
|
|
$global:Clock = 0
|
|
function Start-Sleep([int]$Seconds) { $global:Clock += $Seconds }
|
|
function Get-Date { [datetime]::Now.AddSeconds($global:Clock) }
|
|
function Test-ExecuteRElevated { $true }
|
|
function Clear-ExecuteRLeftovers { }
|
|
function Invoke-FakeAgent {
|
|
$F.Calls.Add('initialize')
|
|
if (-not $F.FailInitialize) { $F.Running = -not $F.FailStart }
|
|
if ($F.Running -and $F.Token) { $F.Credential = 'valid'; $F.Token = $null }
|
|
$global:LASTEXITCODE = 0
|
|
}
|
|
function Get-ExecuteRService([string]$Name) {
|
|
if (-not $F.Present) { return @{ Exists = $false; Status = 'Missing'; StartType = 'Missing' } }
|
|
return @{ Exists = $true; Status = $(if ($F.Running) { 'Running' } else { 'Stopped' }); StartType = 'Automatic' }
|
|
}
|
|
function Get-ExecuteRState([bool]$Portable) {
|
|
return @{
|
|
Present = $F.Present; Dir = 'C:\Fake'; Exe = 'Invoke-FakeAgent'; ExeExists = $F.Present; ExeWorks = ($F.Present -and $F.Works)
|
|
Version = $(if ($F.Present -and $F.Works) { $F.Version } else { $null }); ServerUrl = $F.Server; PolicyServerUrl = $null
|
|
Credential = $F.Credential; TokenPending = [bool]$F.Token; TokenIsOurs = [bool]($F.Token -and $F.Token -ceq $token); MsiMarker = $F.Present
|
|
Msi = $(if ($F.Present) { @{ ProductCode = '{A}'; Version = $F.Version; CacheOk = $true } } else { $null })
|
|
Agent = (Get-ExecuteRService $agentServiceName); Watchdog = (Get-ExecuteRService $watchdogServiceName); WatchdogExpected = $F.Present
|
|
}
|
|
}
|
|
function Get-ExecuteRStatus([string]$Exe) { [pscustomobject]@{ credential = $F.Credential; bootstrapTokenPending = [bool]$F.Token } }
|
|
function Install-ExecuteRPackage([bool]$Portable, [bool]$Enroll, [bool]$Downgrade) {
|
|
$F.Calls.Add('package:' + $Enroll)
|
|
$F.Present = $true; $F.Works = $true; $F.Version = $F.Package; $F.Server = $server
|
|
if ($Enroll) { $F.Token = $token }
|
|
$F.Running = -not $F.FailStart
|
|
if ($F.Running -and $F.Token) { $F.Credential = 'valid'; $F.Token = $null }
|
|
}
|
|
function Set-ExecuteREnrollment { $F.Calls.Add('enroll'); $F.Server = $server; $F.Token = $token }
|
|
function Stop-ExecuteRService([string]$Name) { $F.Calls.Add('stop:' + $Name); if ($Name -eq $agentServiceName) { $F.Running = $false } }
|
|
function Restart-ExecuteRAgent {
|
|
$F.Calls.Add('restart')
|
|
$F.Running = -not $F.FailStart
|
|
if ($F.Running -and $F.Token) { $F.Credential = 'valid'; $F.Token = $null }
|
|
}
|
|
""";
|
|
|
|
public static TheoryData<string, string, int, string, string, string> WindowsRuns => new()
|
|
{
|
|
// name, device ($F changes), exit code, outcome line start, calls (in order), calls that must not happen
|
|
{ "nothing installed", "$F.Present = $false", 0, "Installed: ExecuteR Agent 1.5.0 is running for https://control.example.com, enrolled", "package:True", "initialize" },
|
|
{ "healthy and current", "", 0, "Already Installed: ExecuteR Agent 1.5.0 is running for https://control.example.com", "", "package:True,package:False,initialize,enroll,restart" },
|
|
{ "older", "$F.Version = '1.4.0'", 0, "Upgraded: ExecuteR Agent 1.5.0 is running", "package:False", "enroll,initialize" },
|
|
{ "stopped", "$F.Running = $false", 0, "Repaired: ExecuteR Agent 1.5.0 is running", "initialize", "package:False,enroll" },
|
|
{ "restart does not help", "$F.Running = $false; $F.FailInitialize = $true", 0, "Repaired: ExecuteR Agent 1.5.0 is running", "initialize,package:False", "enroll" },
|
|
{ "binary broken", "$F.Works = $false", 0, "Repaired: ExecuteR Agent 1.5.0 is running", "package:False", "initialize,enroll" },
|
|
{ "enrolled elsewhere", "$F.Server = 'https://old.example.com'", 0, "Repaired: ExecuteR Agent 1.5.0 is running for https://control.example.com, enrolled", "enroll,restart", "package:False,initialize" },
|
|
{ "credential missing", "$F.Credential = 'missing'", 0, "Repaired: ExecuteR Agent 1.5.0 is running", "enroll,restart", "package:False" },
|
|
{ "keeps stopping", "$F.Running = $false; $F.FailStart = $true", 1, "Failed: the agent is not healthy: the agent service is stopped", "initialize,package:False", "" },
|
|
};
|
|
|
|
[Theory]
|
|
[MemberData(nameof(WindowsRuns))]
|
|
public async Task TheWindowsScriptDoesOnlyWhatTheDeviceNeeds(string name, string device, int exitCode, string outcome, string calls, string never)
|
|
{
|
|
var shell = WindowsPowerShell() ?? Pwsh();
|
|
Assert.SkipWhen(shell is null, "Needs Windows PowerShell or pwsh.");
|
|
var script = new StringBuilder("""
|
|
$ErrorActionPreference = 'Stop'
|
|
$server = 'https://control.example.com'
|
|
$token = 's3cret-token'
|
|
$msiUrl = 'x'; $zipUrl = 'x'; $msiVersion = '1.5.0'; $zipVersion = '1.5.0'; $portableOnly = $false
|
|
|
|
""")
|
|
.AppendLine(InstallScripts.WindowsFunctions)
|
|
.AppendLine(WindowsFakes)
|
|
.AppendLine("""
|
|
$F = @{ Present = $true; Works = $true; Version = '1.5.0'; Package = '1.5.0'; Running = $true; Server = 'https://control.example.com'
|
|
Credential = 'valid'; Token = $null; FailStart = $false; FailInitialize = $false; Calls = New-Object System.Collections.Generic.List[string] }
|
|
""")
|
|
.AppendLine(device)
|
|
.AppendLine("try {")
|
|
.AppendLine(InstallScripts.WindowsMain)
|
|
.AppendLine("} finally { Write-Host ('calls=' + ($F.Calls -join ',')) }");
|
|
using var folder = new ScratchFolder();
|
|
var (code, output, stdout) = await RunAsync(shell!, $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -File \"{folder.Write("run.ps1", script.ToString())}\"");
|
|
|
|
Assert.DoesNotContain("s3cret-token", output);
|
|
var lines = Lines(stdout).ToList();
|
|
var made = lines.Single(l => l.StartsWith("calls=", StringComparison.Ordinal))["calls=".Length..].Split(',', StringSplitOptions.RemoveEmptyEntries);
|
|
Assert.True(code == exitCode, $"{name}: exit {code}\n{output}");
|
|
Assert.True(lines.Any(l => l.StartsWith(outcome, StringComparison.Ordinal)), $"{name}: no '{outcome}'\n{output}");
|
|
Assert.True(lines.IndexOf(lines.First(l => l.StartsWith(outcome, StringComparison.Ordinal))) == lines.Count - 2, $"{name}: the outcome is not the last line\n{output}");
|
|
var expected = calls.Split(',', StringSplitOptions.RemoveEmptyEntries);
|
|
Assert.True(expected.SequenceEqual(made.Where(expected.Contains).Distinct()), $"{name}: calls {string.Join(',', made)}\n{output}");
|
|
foreach (var call in never.Split(',', StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
Assert.DoesNotContain(call, made);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task AFailureMasksTheTokenInItsOutcomeLine()
|
|
{
|
|
var shell = WindowsPowerShell() ?? Pwsh();
|
|
Assert.SkipWhen(shell is null, "Needs Windows PowerShell or pwsh.");
|
|
var body = "$server = 'x'; $token = 'abc123'\n" + InstallScripts.WindowsFunctions + "\nWrite-Output (Hide-ExecuteRToken 'GET https://x/?token=abc123 failed')\n";
|
|
using var folder = new ScratchFolder();
|
|
var (code, output, _) = await RunAsync(shell!, $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -File \"{folder.Write("mask.ps1", body)}\"");
|
|
Assert.True(code == 0, output);
|
|
Assert.Contains("token=<token> failed", output);
|
|
Assert.DoesNotContain("abc123", output);
|
|
}
|
|
|
|
private static void AssertVersionResults(Dictionary<string, string> results, string output)
|
|
{
|
|
for (var i = 0; i < VersionPairs.Length; i++)
|
|
{
|
|
var expected = Math.Sign(AgentVersions.Compare(VersionPairs[i].Left, VersionPairs[i].Right)).ToString();
|
|
Assert.True(results.TryGetValue(i.ToString(), out var actual) && actual == expected,
|
|
$"{VersionPairs[i].Left} vs {VersionPairs[i].Right}: expected {expected}, got {actual}\n{output}");
|
|
}
|
|
}
|
|
|
|
private static Dictionary<string, string> Results(string output)
|
|
=> Lines(output)
|
|
.Select(line => ResultLine().Match(line))
|
|
.Where(match => match.Success)
|
|
.ToDictionary(match => match.Groups[1].Value, match => match.Groups[2].Value);
|
|
|
|
[GeneratedRegex(@"^(\d+)=(.*)$")]
|
|
private static partial Regex ResultLine();
|
|
|
|
/// <summary>The token variable itself ($token, ${token}), not $token_pending.</summary>
|
|
[GeneratedRegex(@"\$\{?token\b")]
|
|
private static partial Regex TokenVariable();
|
|
|
|
private static IEnumerable<string> Lines(string text)
|
|
=> text.Split('\n').Select(line => line.TrimEnd('\r').Trim()).Where(line => line.Length > 0);
|
|
|
|
private static string? WindowsPowerShell()
|
|
{
|
|
if (!OperatingSystem.IsWindows())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var path = Path.Combine(Environment.SystemDirectory, @"WindowsPowerShell\v1.0\powershell.exe");
|
|
return File.Exists(path) ? path : null;
|
|
}
|
|
|
|
private static string? Pwsh() => FindOnPath(OperatingSystem.IsWindows() ? "pwsh.exe" : "pwsh");
|
|
|
|
/// <summary>Git Bash first on Windows: System32's bash.exe is WSL's, which cannot take a Windows path.</summary>
|
|
private static string? Bash()
|
|
{
|
|
if (OperatingSystem.IsWindows())
|
|
{
|
|
var git = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), @"Git\bin\bash.exe");
|
|
return File.Exists(git) ? git : null;
|
|
}
|
|
|
|
return FindOnPath("bash");
|
|
}
|
|
|
|
private static string? FindOnPath(string name)
|
|
=> (Environment.GetEnvironmentVariable("PATH") ?? "")
|
|
.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(directory => Path.Combine(directory, name))
|
|
.FirstOrDefault(File.Exists);
|
|
|
|
private static string ForBash(string path) => path.Replace('\\', '/');
|
|
|
|
private static async Task<(int Code, string Output, string Stdout)> RunAsync(string fileName, string arguments, Dictionary<string, string>? environment = null)
|
|
{
|
|
var info = new ProcessStartInfo(fileName, arguments)
|
|
{
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
UseShellExecute = false,
|
|
};
|
|
foreach (var (name, value) in environment ?? [])
|
|
{
|
|
info.Environment[name] = value;
|
|
}
|
|
|
|
using var process = Process.Start(info)!;
|
|
var output = process.StandardOutput.ReadToEndAsync();
|
|
var errors = process.StandardError.ReadToEndAsync();
|
|
using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(2));
|
|
await process.WaitForExitAsync(timeout.Token);
|
|
return (process.ExitCode, await output + await errors, await output);
|
|
}
|
|
|
|
private sealed class ScratchFolder : IDisposable
|
|
{
|
|
public string Path { get; } = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "executer-install-" + Guid.NewGuid().ToString("N"));
|
|
|
|
public ScratchFolder() => Directory.CreateDirectory(Path);
|
|
|
|
public string Write(string name, string content)
|
|
{
|
|
var file = System.IO.Path.Combine(Path, name);
|
|
File.WriteAllText(file, content);
|
|
return file;
|
|
}
|
|
|
|
public void Dispose() => Directory.Delete(Path, recursive: true);
|
|
}
|
|
}
|