Public Access
jaap-jan
8a77b7ca68
The connecting card set its status string once, when the tab was created, and never touched it again. Every connection therefore looked identical from the outside: one three seconds into a key exchange, one waiting out a fifteen-second timeout against a machine that is asleep, and one that had hung all drew the same "connecting…". The card now draws the five steps of getting there, each lit at the moment the handshake reports reaching it, over an amber track that fills as they finish. ◆ NOTHING ON THE LIST IS INVENTED. Every row changes state because a layer below it said so, at the instant the thing it names actually began. That is the whole reason it is worth showing, and it is why most of this commit is plumbing rather than XAML: there was no progress reporting anywhere in the stack to hook a step list onto, and a card animating plausible progress would have been indistinguishable from one that had stopped receiving any. SshConnectionPhase names four phases and deliberately not more. SSH.NET runs the entire handshake inside one ConnectAsync and raises exactly one event from the middle of it — HostKeyReceived, once the key exchange has produced a key to show — so that event is the only interior moment there is to report. Everything before it is Reaching and everything after it is Authenticating. A fifth phase in that assembly would have to be a timer, so there is not one. OpeningShell is reported by TerminalWorkspace instead, because that is where it happens: the factory's work ends with an authenticated connection, and asking for a pseudo-terminal on one is a separate round trip. The SFTP path passes null — a second connection opened behind an already-open shell has nobody watching a step list for it. The card's fifth step, "Starting the terminal", is the renderer wait and lives in the shell rather than in the SSH assembly, which has never heard of a renderer. On the first connection after a cold start it is a real wait with a real failure mode of its own — a missing WebView2 runtime — so a list that began at "reaching the host" would leave the one wait most likely to hang unnamed. Amber for the step in flight, and that follows the palette's rule rather than bending it. Green is what is true and purple is what you can press; a step still happening is neither, and it is exactly the caveat-worth-reading that amber exists for. Steps behind it go green as they become true. Nothing animates, which is the argument TransfersScreen.axaml already makes for its own track, reaching a screen with far more reason to want a spinner: a spinner is furniture invented to fill a state nobody measured, and these states are measured, so the track fills to what has finished and then waits there. A refusal keeps the step it stopped on, in red, with the ones behind it still green. That is the half a progress bar could not do, and it is the difference between "that host is not there" and "that host is there and would not have me" — a question the reason sentence alone frequently does not settle. The strip's dot goes amber while a tab is connecting, on both heads. It was grey, and so is a tab whose shell has exited: the two states in that strip with the least in common, one worth waiting for and one over. PhoneShell's own comment already recorded half of this — the dot stopped being green before anything had answered — and this is the other half. Progress is raised inline rather than through System.Progress<T>, which captures whatever synchronisation context it was constructed on and posts to it. That reads like a convenience and is really a second place the marshalling decision gets made: silently, differently under a test with no context, and out of order with respect to the failure that follows a phase. The shell marshals once, in one handler, through a new optional post parameter on MainWindowViewModel — the same seam TransfersViewModel already uses, and for the reason its own remark gives. The three Dispatcher.UIThread.Post calls that predate it are the ones this suite's comments record as out of reach; they are left alone rather than swept in here. Both heads draw the list. They differ in one place: Phone.axaml's mono class sets a colour and a size along with the family, so the caption rule names its own family instead of composing the two and asking two rules for one Foreground. The desktop's mono sets the family alone, which is why ConnectingCard does compose them. Each head also gains SHOW LOGS beside the button that gives up — the step list is this attempt and the log is every other one, which is what a connection taking too long actually raises. Seven tests, and the two that matter most run against the container rather than a fake: a real handshake reports its phases in order, and a host-key refusal never claims to have authenticated. A fake asserting what it was written to assert would have established nothing about either. The rest cover the tab advancing while the connection is gated, the step a refusal stops on, and a phase reported after the user has given up on the tab. 1,861 tests, none failing. The Android head's layout is not verified by anything. It compiles, and compiled bindings mean every new binding path resolves, but that project is not in DodoSSH.slnx, there is no test project for it and no device here — so unlike the desktop card, whose shapes the layout harness measures, these rows have not been drawn. Vertical fit is reasoned, not observed.
254 lines
9.6 KiB
C#
254 lines
9.6 KiB
C#
using System.Globalization;
|
|
using System.Net.WebSockets;
|
|
using System.Text;
|
|
using DodoSSH.Client.Terminal;
|
|
|
|
namespace DodoSSH.Client.Ssh.Tests;
|
|
|
|
/// <summary>
|
|
/// A real SSH session, through the real data plane, to a stand-in renderer.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Everything the desktop client does when a user opens a terminal, minus the pixels: a real
|
|
/// <c>sshd</c> in a container, a real pseudo-terminal, the real loopback WebSocket with its token and
|
|
/// origin checks, and a <see cref="ClientWebSocket"/> standing in for the page. If a shell prompt
|
|
/// arrives here and typed input round-trips, the only untested link left is xterm drawing bytes it was
|
|
/// handed.
|
|
/// </para>
|
|
/// <para>
|
|
/// Worth having because the alternative is driving a GUI. The WebView's own participation is
|
|
/// verifiable separately — it opens a TCP connection to this same port — but that says nothing about
|
|
/// whether an SSH session's output reaches it.
|
|
/// </para>
|
|
/// </remarks>
|
|
[Collection(SshCollection.Name)]
|
|
public sealed class TerminalEndToEndTests(SshServerFixture fixture)
|
|
{
|
|
private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(30);
|
|
|
|
/// <remarks>
|
|
/// The real page is an Avalonia resource in the app project. This test stands in for the renderer
|
|
/// itself, so a placeholder-bearing stub is all the transport needs.
|
|
/// </remarks>
|
|
private static InMemoryTerminalAssetProvider StubAssets() =>
|
|
new(new Dictionary<string, TerminalAsset>(StringComparer.Ordinal)
|
|
{
|
|
[TerminalDataPlane.PagePath] = new(
|
|
"text/html; charset=utf-8",
|
|
Encoding.UTF8.GetBytes(
|
|
$"<html data-token=\"{TerminalDataPlane.TokenPlaceholder}\" "
|
|
+ $"data-socket=\"{TerminalDataPlane.SocketUrlPlaceholder}\"></html>")),
|
|
});
|
|
|
|
[Fact]
|
|
public async Task AShellSessionReachesTheRenderer_AndInputReachesTheRemote()
|
|
{
|
|
var knownHosts = new InMemoryKnownHostStore();
|
|
|
|
await using var workspace = new TerminalWorkspace(
|
|
StubAssets(),
|
|
new SshNetConnectionFactory(knownHosts),
|
|
TimeProvider.System);
|
|
|
|
workspace.Start();
|
|
|
|
// The token comes from the served page, exactly as the real renderer obtains it.
|
|
var token = await ReadTokenAsync(workspace.PageUrl);
|
|
|
|
using var renderer = await AttachAsync(workspace.PageUrl, token);
|
|
await workspace.WaitForRendererAsync(TestContext.Current.CancellationToken);
|
|
|
|
var sessionId = await OpenTrustedSessionAsync(workspace, knownHosts);
|
|
|
|
// SessionOpened tells the renderer to create a terminal before any output arrives for it.
|
|
var opened = await ReceiveAsync(renderer);
|
|
opened.Opcode.ShouldBe((byte)TerminalServerOpcode.SessionOpened);
|
|
opened.SessionId.ShouldBe(sessionId);
|
|
|
|
// The login banner and prompt arrive unprompted, acknowledged as the page does from
|
|
// term.write's callback.
|
|
var banner = await ReadOutputUntilAsync(renderer, sessionId, "$", acknowledge: true);
|
|
banner.ShouldContain("OpenSSH");
|
|
|
|
// Marker split so the PTY's echo of the command line does not satisfy the match.
|
|
await SendAsync(
|
|
renderer,
|
|
sessionId,
|
|
(byte)TerminalClientOpcode.Input,
|
|
Encoding.UTF8.GetBytes("echo \"DODO\"\"SSH-OK\"; stty size\n"));
|
|
|
|
var output = await ReadOutputUntilAsync(renderer, sessionId, "DODOSSH-OK", acknowledge: true);
|
|
|
|
output.ShouldContain("DODOSSH-OK");
|
|
|
|
// The size requested when the session opened is the size the remote sees, which means the
|
|
// pty-req carried it rather than the terminal silently defaulting to 80x24.
|
|
output.Replace('\r', '\n').ShouldContain("30 100");
|
|
|
|
await workspace.CloseSessionAsync(sessionId);
|
|
}
|
|
|
|
// ---- Helpers ----
|
|
|
|
/// <summary>
|
|
/// Trusts the container's host key, then opens a session.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The refused first attempt is part of the assertion, not setup noise: a host with no pinned key
|
|
/// must not connect, and the fingerprint the user would be shown has to be in the exception.
|
|
/// </remarks>
|
|
private async Task<uint> OpenTrustedSessionAsync(
|
|
TerminalWorkspace workspace,
|
|
InMemoryKnownHostStore knownHosts)
|
|
{
|
|
var request = new SshConnectionRequest(
|
|
fixture.Host,
|
|
fixture.Port,
|
|
SshServerFixture.Username,
|
|
new SshPasswordCredential(SshServerFixture.Password));
|
|
|
|
var unknown = await Should.ThrowAsync<SshHostKeyUnknownException>(async () =>
|
|
await workspace.OpenSessionAsync(
|
|
request, TerminalSize.Default, progress: null, TestContext.Current.CancellationToken));
|
|
|
|
unknown.Presentation.Fingerprint.ShouldStartWith(SshHostKeyFingerprint.Prefix);
|
|
|
|
await knownHosts.TrustAsync(unknown.Presentation, TestContext.Current.CancellationToken);
|
|
|
|
return await workspace.OpenSessionAsync(
|
|
request,
|
|
new TerminalSize(100, 30, 1000, 750),
|
|
progress: null,
|
|
TestContext.Current.CancellationToken);
|
|
}
|
|
|
|
private static async Task<string> ReadTokenAsync(Uri pageUrl)
|
|
{
|
|
using var client = new HttpClient();
|
|
var page = await client.GetStringAsync(pageUrl, TestContext.Current.CancellationToken);
|
|
|
|
const string Marker = "data-token=\"";
|
|
var start = page.IndexOf(Marker, StringComparison.Ordinal) + Marker.Length;
|
|
var end = page.IndexOf('"', start);
|
|
|
|
return page[start..end];
|
|
}
|
|
|
|
private static async Task<ClientWebSocket> AttachAsync(Uri pageUrl, string token)
|
|
{
|
|
var socket = new ClientWebSocket();
|
|
|
|
socket.Options.AddSubProtocol(TerminalDataPlane.SubProtocol);
|
|
socket.Options.AddSubProtocol($"token.{token}");
|
|
socket.Options.SetRequestHeader(
|
|
"Origin",
|
|
string.Create(CultureInfo.InvariantCulture, $"http://127.0.0.1:{pageUrl.Port}"));
|
|
|
|
try
|
|
{
|
|
await socket.ConnectAsync(
|
|
new Uri($"ws://127.0.0.1:{pageUrl.Port}{TerminalDataPlane.SocketPath}"),
|
|
TestContext.Current.CancellationToken);
|
|
}
|
|
catch
|
|
{
|
|
socket.Dispose();
|
|
throw;
|
|
}
|
|
|
|
return socket;
|
|
}
|
|
|
|
private static Task SendAsync(
|
|
ClientWebSocket socket,
|
|
uint sessionId,
|
|
byte opcode,
|
|
byte[] payload) =>
|
|
socket.SendAsync(
|
|
TerminalFrame.Create(opcode, sessionId, payload),
|
|
WebSocketMessageType.Binary,
|
|
endOfMessage: true,
|
|
TestContext.Current.CancellationToken);
|
|
|
|
/// <remarks>
|
|
/// Bounded by its own timeout rather than relying on a caller's deadline. A blocking receive is
|
|
/// where a missing frame turns into a hung test run instead of a failure with a message, and a hang
|
|
/// tells you nothing about which frame never came.
|
|
/// </remarks>
|
|
private static async Task<(byte Opcode, uint SessionId, byte[] Payload)> ReceiveAsync(
|
|
ClientWebSocket socket)
|
|
{
|
|
var buffer = new byte[256 * 1024];
|
|
|
|
using var deadline = new CancellationTokenSource(Timeout);
|
|
using var linked = CancellationTokenSource.CreateLinkedTokenSource(
|
|
deadline.Token,
|
|
TestContext.Current.CancellationToken);
|
|
|
|
WebSocketReceiveResult result;
|
|
try
|
|
{
|
|
result = await socket.ReceiveAsync(buffer, linked.Token);
|
|
}
|
|
catch (OperationCanceledException) when (deadline.IsCancellationRequested)
|
|
{
|
|
throw new TimeoutException($"No terminal frame arrived within {Timeout}.");
|
|
}
|
|
|
|
TerminalFrame.TryRead(
|
|
buffer.AsSpan(0, result.Count), out var opcode, out var sessionId, out var payload)
|
|
.ShouldBeTrue();
|
|
|
|
return (opcode, sessionId, payload.ToArray());
|
|
}
|
|
|
|
/// <summary>Reads output frames until the text appears, acknowledging each as the page does.</summary>
|
|
private static async Task<string> ReadOutputUntilAsync(
|
|
ClientWebSocket socket,
|
|
uint sessionId,
|
|
string expected,
|
|
bool acknowledge)
|
|
{
|
|
var accumulated = new StringBuilder();
|
|
var deadline = TimeProvider.System.GetUtcNow() + Timeout;
|
|
|
|
while (TimeProvider.System.GetUtcNow() < deadline)
|
|
{
|
|
var frame = await ReceiveAsync(socket);
|
|
|
|
if (frame.Opcode == (byte)TerminalServerOpcode.SessionClosed)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"The session closed before '{expected}' arrived: "
|
|
+ $"{Encoding.UTF8.GetString(frame.Payload)}\nSeen so far:\n{accumulated}");
|
|
}
|
|
|
|
if (frame.Opcode != (byte)TerminalServerOpcode.Output)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (acknowledge)
|
|
{
|
|
// Returning credit is what keeps the pump reading. Without it the session stalls at
|
|
// the window size and this loop would time out on a working implementation.
|
|
await SendAsync(
|
|
socket,
|
|
sessionId,
|
|
(byte)TerminalClientOpcode.Acknowledge,
|
|
TerminalFrame.CreateAcknowledgementPayload((uint)frame.Payload.Length));
|
|
}
|
|
|
|
accumulated.Append(Encoding.UTF8.GetString(frame.Payload));
|
|
|
|
if (accumulated.ToString().Contains(expected, StringComparison.Ordinal))
|
|
{
|
|
return accumulated.ToString();
|
|
}
|
|
}
|
|
|
|
throw new TimeoutException($"'{expected}' did not arrive within {Timeout}.\n{accumulated}");
|
|
}
|
|
}
|