mirror of
https://github.com/par274/sharpemu.git
synced 2026-08-08 02:39:10 +08:00
Add live debugger frontend and mutex stall recovery (#383)
This commit is contained in:
Spooks
@@ -0,0 +1,340 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
using SharpEmu.Debugger.Breakpoints;
|
||||
using SharpEmu.Debugger.Session;
|
||||
using SharpEmu.HLE;
|
||||
|
||||
namespace SharpEmu.Debugger.Protocol;
|
||||
|
||||
/// <summary>
|
||||
/// Translates parsed <see cref="DebugRequest"/> verbs into operations on an
|
||||
/// <see cref="IDebuggerSession"/> and packages the outcome as a
|
||||
/// <see cref="DebugResponse"/>. This is the single place command semantics live,
|
||||
/// so it is shared by every connection and independent of the wire format.
|
||||
/// </summary>
|
||||
public sealed class DebugCommandDispatcher
|
||||
{
|
||||
private readonly IDebuggerSession _session;
|
||||
|
||||
public DebugCommandDispatcher(IDebuggerSession session)
|
||||
{
|
||||
_session = session ?? throw new ArgumentNullException(nameof(session));
|
||||
}
|
||||
|
||||
public DebugResponse Dispatch(DebugRequest request)
|
||||
{
|
||||
return request.Command switch
|
||||
{
|
||||
JsonLineDebugProtocol.ParseErrorCommand => ParseError(request),
|
||||
"ping" => DebugResponse.Success(request.Command),
|
||||
"status" or "info" => Status(request),
|
||||
"state" => DebugResponse.Success(request.Command, new Dictionary<string, object?>
|
||||
{
|
||||
["state"] = _session.State.ToString(),
|
||||
}),
|
||||
"registers" or "regs" => Registers(request),
|
||||
"set-register" or "set-reg" => SetRegister(request),
|
||||
"read-memory" or "read-mem" => ReadMemory(request),
|
||||
"write-memory" or "write-mem" => WriteMemory(request),
|
||||
"list-breakpoints" or "breakpoints" => ListBreakpoints(request),
|
||||
"add-breakpoint" or "break" => AddBreakpoint(request),
|
||||
"remove-breakpoint" or "delete-breakpoint" => RemoveBreakpoint(request),
|
||||
"enable-breakpoint" => EnableBreakpoint(request),
|
||||
"continue" or "cont" or "c" => Simple(request, _session.Continue(), "Target is not paused."),
|
||||
"step" or "s" => Simple(request, _session.StepFrame(), "Target is not paused."),
|
||||
"pause" => Pause(request),
|
||||
_ => DebugResponse.Failure(request.Command, $"Unknown command '{request.Command}'."),
|
||||
};
|
||||
}
|
||||
|
||||
private static DebugResponse ParseError(DebugRequest request)
|
||||
{
|
||||
var message = request.TryGetString("message", out var text) ? text : "Malformed request.";
|
||||
return DebugResponse.Failure(request.Command, message);
|
||||
}
|
||||
|
||||
private DebugResponse Status(DebugRequest request)
|
||||
{
|
||||
var data = new Dictionary<string, object?>
|
||||
{
|
||||
["state"] = _session.State.ToString(),
|
||||
["breakpoints"] = _session.Breakpoints.Snapshot().Count,
|
||||
};
|
||||
|
||||
if (_session.LastStop is { } stop)
|
||||
{
|
||||
data["lastStop"] = DescribeStop(stop);
|
||||
}
|
||||
|
||||
return DebugResponse.Success(request.Command, data);
|
||||
}
|
||||
|
||||
private DebugResponse Registers(DebugRequest request)
|
||||
{
|
||||
if (!_session.TryGetRegisters(out var registers))
|
||||
{
|
||||
return NotPaused(request);
|
||||
}
|
||||
|
||||
return DebugResponse.Success(request.Command, new Dictionary<string, object?>
|
||||
{
|
||||
["registers"] = DescribeRegisters(registers),
|
||||
});
|
||||
}
|
||||
|
||||
private DebugResponse SetRegister(DebugRequest request)
|
||||
{
|
||||
if (!request.TryGetString("register", out var name) || !TryParseRegister(name, out var id))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected a valid 'register' name.");
|
||||
}
|
||||
|
||||
if (!request.TryGetUInt64("value", out var value))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected a 'value'.");
|
||||
}
|
||||
|
||||
return _session.TrySetRegister(id, value)
|
||||
? DebugResponse.Success(request.Command)
|
||||
: DebugResponse.Failure(request.Command, "Register is not writable or target is not paused.");
|
||||
}
|
||||
|
||||
private DebugResponse ReadMemory(DebugRequest request)
|
||||
{
|
||||
if (!request.TryGetUInt64("address", out var address))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected an 'address'.");
|
||||
}
|
||||
|
||||
if (!request.TryGetInt32("length", out var length) || length <= 0 || length > MaxMemoryChunk)
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, $"Expected a 'length' between 1 and {MaxMemoryChunk}.");
|
||||
}
|
||||
|
||||
var buffer = new byte[length];
|
||||
if (!_session.TryReadMemory(address, buffer))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Memory is unreadable or target is not paused.");
|
||||
}
|
||||
|
||||
return DebugResponse.Success(request.Command, new Dictionary<string, object?>
|
||||
{
|
||||
["address"] = FormatAddress(address),
|
||||
["length"] = length,
|
||||
["bytes"] = Convert.ToHexString(buffer),
|
||||
});
|
||||
}
|
||||
|
||||
private DebugResponse WriteMemory(DebugRequest request)
|
||||
{
|
||||
if (!request.TryGetUInt64("address", out var address))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected an 'address'.");
|
||||
}
|
||||
|
||||
if (!request.TryGetString("bytes", out var hex) || hex.Length == 0 || (hex.Length & 1) != 0)
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected 'bytes' as an even-length hex string.");
|
||||
}
|
||||
|
||||
byte[] data;
|
||||
try
|
||||
{
|
||||
data = Convert.FromHexString(hex);
|
||||
}
|
||||
catch (FormatException)
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "'bytes' is not valid hex.");
|
||||
}
|
||||
|
||||
if (data.Length > MaxMemoryChunk)
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, $"Cannot write more than {MaxMemoryChunk} bytes at once.");
|
||||
}
|
||||
|
||||
return _session.TryWriteMemory(address, data)
|
||||
? DebugResponse.Success(request.Command, new Dictionary<string, object?> { ["written"] = data.Length })
|
||||
: DebugResponse.Failure(request.Command, "Memory is unwritable or target is not paused.");
|
||||
}
|
||||
|
||||
private DebugResponse ListBreakpoints(DebugRequest request)
|
||||
{
|
||||
var breakpoints = _session.Breakpoints.Snapshot()
|
||||
.OrderBy(breakpoint => breakpoint.Id)
|
||||
.Select(DescribeBreakpoint)
|
||||
.ToArray();
|
||||
|
||||
return DebugResponse.Success(request.Command, new Dictionary<string, object?>
|
||||
{
|
||||
["breakpoints"] = breakpoints,
|
||||
});
|
||||
}
|
||||
|
||||
private DebugResponse AddBreakpoint(DebugRequest request)
|
||||
{
|
||||
if (!request.TryGetUInt64("address", out var address))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected an 'address'.");
|
||||
}
|
||||
|
||||
var kind = BreakpointKind.Execute;
|
||||
if (request.TryGetString("kind", out var kindText) && !TryParseBreakpointKind(kindText, out kind))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, $"Unknown breakpoint kind '{kindText}'.");
|
||||
}
|
||||
|
||||
var length = 1UL;
|
||||
if (request.TryGetUInt64("length", out var requestedLength) && requestedLength > 0)
|
||||
{
|
||||
length = requestedLength;
|
||||
}
|
||||
|
||||
var breakpoint = _session.Breakpoints.Add(kind, address, length);
|
||||
return DebugResponse.Success(request.Command, new Dictionary<string, object?>
|
||||
{
|
||||
["breakpoint"] = DescribeBreakpoint(breakpoint),
|
||||
});
|
||||
}
|
||||
|
||||
private DebugResponse RemoveBreakpoint(DebugRequest request)
|
||||
{
|
||||
if (!request.TryGetInt32("id", out var id))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected an 'id'.");
|
||||
}
|
||||
|
||||
return _session.Breakpoints.Remove(id)
|
||||
? DebugResponse.Success(request.Command)
|
||||
: DebugResponse.Failure(request.Command, $"No breakpoint with id {id}.");
|
||||
}
|
||||
|
||||
private DebugResponse EnableBreakpoint(DebugRequest request)
|
||||
{
|
||||
if (!request.TryGetInt32("id", out var id))
|
||||
{
|
||||
return DebugResponse.Failure(request.Command, "Expected an 'id'.");
|
||||
}
|
||||
|
||||
var enabled = !request.TryGetBool("enabled", out var requested) || requested;
|
||||
return _session.Breakpoints.SetEnabled(id, enabled)
|
||||
? DebugResponse.Success(request.Command)
|
||||
: DebugResponse.Failure(request.Command, $"No breakpoint with id {id}.");
|
||||
}
|
||||
|
||||
private DebugResponse Pause(DebugRequest request)
|
||||
{
|
||||
_session.RequestPause();
|
||||
return DebugResponse.Success(request.Command);
|
||||
}
|
||||
|
||||
private static DebugResponse Simple(DebugRequest request, bool succeeded, string failureMessage)
|
||||
=> succeeded ? DebugResponse.Success(request.Command) : DebugResponse.Failure(request.Command, failureMessage);
|
||||
|
||||
private static DebugResponse NotPaused(DebugRequest request)
|
||||
=> DebugResponse.Failure(request.Command, "Target is not paused.");
|
||||
|
||||
internal static IReadOnlyDictionary<string, object?> DescribeStop(DebugStopEvent stop)
|
||||
{
|
||||
var data = new Dictionary<string, object?>
|
||||
{
|
||||
["reason"] = stop.Reason.ToString(),
|
||||
["address"] = FormatAddress(stop.Address),
|
||||
["frameKind"] = stop.FrameKind.ToString(),
|
||||
["frameLabel"] = stop.FrameLabel,
|
||||
["registers"] = DescribeRegisters(stop.Registers),
|
||||
};
|
||||
|
||||
if (stop.Breakpoint is { } breakpoint)
|
||||
{
|
||||
data["breakpoint"] = DescribeBreakpoint(breakpoint);
|
||||
}
|
||||
|
||||
if (stop.Result is { } result)
|
||||
{
|
||||
data["result"] = result.ToString();
|
||||
}
|
||||
|
||||
if (stop.Detail is { } detail)
|
||||
{
|
||||
data["detail"] = detail;
|
||||
}
|
||||
|
||||
if (stop.OpcodeBytes is { } opcodeBytes)
|
||||
{
|
||||
data["opcodeBytes"] = opcodeBytes;
|
||||
}
|
||||
|
||||
if (stop.StallInfo is { } stall)
|
||||
{
|
||||
data["stall"] = new Dictionary<string, object?>
|
||||
{
|
||||
["kind"] = stall.Kind.ToString(),
|
||||
["nid"] = stall.Nid,
|
||||
["instructionPointer"] = FormatAddress(stall.InstructionPointer),
|
||||
["dispatchIndex"] = stall.DispatchIndex,
|
||||
["argument0"] = FormatAddress(stall.Argument0),
|
||||
["argument1"] = FormatAddress(stall.Argument1),
|
||||
["resolved"] = stall.IsResolved,
|
||||
["library"] = stall.LibraryName,
|
||||
["function"] = stall.FunctionName,
|
||||
};
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
private static IReadOnlyDictionary<string, object?> DescribeRegisters(DebugRegisterFile registers)
|
||||
{
|
||||
var result = new Dictionary<string, object?>(20);
|
||||
for (var i = 0; i < 16; i++)
|
||||
{
|
||||
result[((CpuRegister)i).ToString().ToLowerInvariant()] = FormatAddress(registers[(CpuRegister)i]);
|
||||
}
|
||||
|
||||
result["rip"] = FormatAddress(registers.Rip);
|
||||
result["rflags"] = FormatAddress(registers.Rflags);
|
||||
result["fs_base"] = FormatAddress(registers.FsBase);
|
||||
result["gs_base"] = FormatAddress(registers.GsBase);
|
||||
return result;
|
||||
}
|
||||
|
||||
private static IReadOnlyDictionary<string, object?> DescribeBreakpoint(Breakpoint breakpoint)
|
||||
=> new Dictionary<string, object?>
|
||||
{
|
||||
["id"] = breakpoint.Id,
|
||||
["kind"] = breakpoint.Kind.ToString(),
|
||||
["address"] = FormatAddress(breakpoint.Address),
|
||||
["length"] = breakpoint.Length,
|
||||
["enabled"] = breakpoint.Enabled,
|
||||
};
|
||||
|
||||
private static string FormatAddress(ulong value) => $"0x{value:X16}";
|
||||
|
||||
private static bool TryParseRegister(string name, out DebugRegisterId id)
|
||||
{
|
||||
var normalized = name.Trim().ToLowerInvariant();
|
||||
switch (normalized)
|
||||
{
|
||||
case "rip":
|
||||
id = DebugRegisterId.Rip;
|
||||
return true;
|
||||
case "rflags":
|
||||
id = DebugRegisterId.Rflags;
|
||||
return true;
|
||||
case "fs_base" or "fsbase":
|
||||
id = DebugRegisterId.FsBase;
|
||||
return true;
|
||||
case "gs_base" or "gsbase":
|
||||
id = DebugRegisterId.GsBase;
|
||||
return true;
|
||||
}
|
||||
|
||||
return Enum.TryParse(normalized, ignoreCase: true, out id) && Enum.IsDefined(id);
|
||||
}
|
||||
|
||||
private static bool TryParseBreakpointKind(string text, out BreakpointKind kind)
|
||||
=> Enum.TryParse(text.Trim(), ignoreCase: true, out kind) && Enum.IsDefined(kind);
|
||||
|
||||
private const int MaxMemoryChunk = 64 * 1024;
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
using System.Globalization;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace SharpEmu.Debugger.Protocol;
|
||||
|
||||
/// <summary>
|
||||
/// A parsed client request: a <see cref="Command"/> verb plus a bag of named
|
||||
/// arguments backed by the original JSON. Numeric arguments accept either JSON
|
||||
/// numbers or <c>"0x"</c>-prefixed hex strings so addresses read naturally on
|
||||
/// the wire.
|
||||
/// </summary>
|
||||
public sealed class DebugRequest
|
||||
{
|
||||
private readonly JsonElement _root;
|
||||
|
||||
private DebugRequest(string command, JsonElement root)
|
||||
{
|
||||
Command = command;
|
||||
_root = root;
|
||||
}
|
||||
|
||||
/// <summary>The lower-cased command verb.</summary>
|
||||
public string Command { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Parses a single JSON object into a request. Returns false when the text is
|
||||
/// not a JSON object or is missing a string <c>command</c> field.
|
||||
/// </summary>
|
||||
public static bool TryParse(string json, out DebugRequest request, out string error)
|
||||
{
|
||||
request = null!;
|
||||
error = string.Empty;
|
||||
try
|
||||
{
|
||||
using var document = JsonDocument.Parse(json);
|
||||
var root = document.RootElement.Clone();
|
||||
if (root.ValueKind != JsonValueKind.Object)
|
||||
{
|
||||
error = "Request must be a JSON object.";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!root.TryGetProperty("command", out var commandElement) ||
|
||||
commandElement.ValueKind != JsonValueKind.String)
|
||||
{
|
||||
error = "Request is missing a string 'command'.";
|
||||
return false;
|
||||
}
|
||||
|
||||
var command = commandElement.GetString() ?? string.Empty;
|
||||
request = new DebugRequest(command.Trim().ToLowerInvariant(), root);
|
||||
return true;
|
||||
}
|
||||
catch (JsonException ex)
|
||||
{
|
||||
error = $"Malformed JSON: {ex.Message}";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public bool TryGetString(string name, out string value)
|
||||
{
|
||||
if (_root.TryGetProperty(name, out var element) && element.ValueKind == JsonValueKind.String)
|
||||
{
|
||||
value = element.GetString() ?? string.Empty;
|
||||
return true;
|
||||
}
|
||||
|
||||
value = string.Empty;
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool TryGetUInt64(string name, out ulong value)
|
||||
{
|
||||
value = 0;
|
||||
if (!_root.TryGetProperty(name, out var element))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (element.ValueKind)
|
||||
{
|
||||
case JsonValueKind.Number:
|
||||
return element.TryGetUInt64(out value);
|
||||
case JsonValueKind.String:
|
||||
return TryParseNumber(element.GetString(), out value);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public bool TryGetInt32(string name, out int value)
|
||||
{
|
||||
value = 0;
|
||||
if (!_root.TryGetProperty(name, out var element))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (element.ValueKind)
|
||||
{
|
||||
case JsonValueKind.Number:
|
||||
return element.TryGetInt32(out value);
|
||||
case JsonValueKind.String when TryParseNumber(element.GetString(), out var parsed) && parsed <= int.MaxValue:
|
||||
value = (int)parsed;
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public bool TryGetBool(string name, out bool value)
|
||||
{
|
||||
value = false;
|
||||
if (!_root.TryGetProperty(name, out var element))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (element.ValueKind)
|
||||
{
|
||||
case JsonValueKind.True:
|
||||
value = true;
|
||||
return true;
|
||||
case JsonValueKind.False:
|
||||
value = false;
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static bool TryParseNumber(string? text, out ulong value)
|
||||
{
|
||||
value = 0;
|
||||
if (string.IsNullOrWhiteSpace(text))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
text = text.Trim();
|
||||
if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return ulong.TryParse(text.AsSpan(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out value);
|
||||
}
|
||||
|
||||
return ulong.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out value);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
namespace SharpEmu.Debugger.Protocol;
|
||||
|
||||
/// <summary>
|
||||
/// The reply to a <see cref="DebugRequest"/>: either success with an optional
|
||||
/// data payload, or a failure with a human-readable message.
|
||||
/// </summary>
|
||||
public sealed class DebugResponse
|
||||
{
|
||||
private DebugResponse(bool ok, string? command, IReadOnlyDictionary<string, object?>? data, string? error)
|
||||
{
|
||||
Ok = ok;
|
||||
Command = command;
|
||||
Data = data;
|
||||
Error = error;
|
||||
}
|
||||
|
||||
public bool Ok { get; }
|
||||
|
||||
/// <summary>Echoes the command the reply answers, when known.</summary>
|
||||
public string? Command { get; }
|
||||
|
||||
public IReadOnlyDictionary<string, object?>? Data { get; }
|
||||
|
||||
public string? Error { get; }
|
||||
|
||||
public static DebugResponse Success(string command, IReadOnlyDictionary<string, object?>? data = null)
|
||||
=> new(ok: true, command, data, error: null);
|
||||
|
||||
public static DebugResponse Failure(string command, string error)
|
||||
=> new(ok: false, command, data: null, error);
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
namespace SharpEmu.Debugger.Protocol;
|
||||
|
||||
/// <summary>
|
||||
/// Frames debugger traffic on a connection. A protocol turns bytes into
|
||||
/// <see cref="DebugRequest"/> objects and serialises <see cref="DebugResponse"/>
|
||||
/// replies plus asynchronous events (stops, resumes, termination) back to the
|
||||
/// client. Swapping the implementation (line-delimited JSON today, a GDB remote
|
||||
/// serial stub later) leaves the session and server untouched.
|
||||
/// </summary>
|
||||
public interface IDebugProtocol
|
||||
{
|
||||
/// <summary>A short protocol name reported in the handshake.</summary>
|
||||
string Name { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Reads the next request, or null at end of stream. Parse failures are
|
||||
/// surfaced as a request with a reserved error command rather than throwing.
|
||||
/// </summary>
|
||||
Task<DebugRequest?> ReadRequestAsync(TextReader reader, CancellationToken cancellationToken);
|
||||
|
||||
/// <summary>Writes a reply to a request.</summary>
|
||||
Task WriteResponseAsync(TextWriter writer, DebugResponse response, CancellationToken cancellationToken);
|
||||
|
||||
/// <summary>Writes an unsolicited event (for example a stop notification).</summary>
|
||||
Task WriteEventAsync(
|
||||
TextWriter writer,
|
||||
string eventName,
|
||||
IReadOnlyDictionary<string, object?> data,
|
||||
CancellationToken cancellationToken);
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
using System.Text.Json;
|
||||
|
||||
namespace SharpEmu.Debugger.Protocol;
|
||||
|
||||
/// <summary>
|
||||
/// A newline-delimited JSON protocol: one JSON object per line in each
|
||||
/// direction. Requests carry a <c>command</c>; replies carry <c>ok</c> plus
|
||||
/// <c>data</c>/<c>error</c>; events carry an <c>event</c> name. It is trivial to
|
||||
/// drive from a socket, <c>nc</c>, or a small script, which suits bring-up and
|
||||
/// tooling while a richer protocol is layered on later.
|
||||
/// </summary>
|
||||
public sealed class JsonLineDebugProtocol : IDebugProtocol
|
||||
{
|
||||
/// <summary>The command assigned to a request that failed to parse.</summary>
|
||||
public const string ParseErrorCommand = "$parse-error";
|
||||
|
||||
private static readonly JsonSerializerOptions SerializerOptions = new()
|
||||
{
|
||||
WriteIndented = false,
|
||||
};
|
||||
|
||||
public string Name => "json-lines/1";
|
||||
|
||||
public async Task<DebugRequest?> ReadRequestAsync(TextReader reader, CancellationToken cancellationToken)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
var line = await reader.ReadLineAsync(cancellationToken).ConfigureAwait(false);
|
||||
if (line is null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (string.IsNullOrWhiteSpace(line))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (DebugRequest.TryParse(line, out var request, out var error))
|
||||
{
|
||||
return request;
|
||||
}
|
||||
|
||||
// Surface the parse failure as a synthetic request so the connection
|
||||
// loop can reply with an error rather than dropping the client.
|
||||
var envelope = $"{{\"command\":\"{ParseErrorCommand}\",\"message\":{JsonSerializer.Serialize(error)}}}";
|
||||
if (DebugRequest.TryParse(envelope, out var errorRequest, out _))
|
||||
{
|
||||
return errorRequest;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task WriteResponseAsync(TextWriter writer, DebugResponse response, CancellationToken cancellationToken)
|
||||
{
|
||||
var payload = new Dictionary<string, object?>
|
||||
{
|
||||
["ok"] = response.Ok,
|
||||
};
|
||||
|
||||
if (response.Command is not null)
|
||||
{
|
||||
payload["command"] = response.Command;
|
||||
}
|
||||
|
||||
if (response.Data is not null)
|
||||
{
|
||||
payload["data"] = response.Data;
|
||||
}
|
||||
|
||||
if (response.Error is not null)
|
||||
{
|
||||
payload["error"] = response.Error;
|
||||
}
|
||||
|
||||
await WriteLineAsync(writer, payload, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async Task WriteEventAsync(
|
||||
TextWriter writer,
|
||||
string eventName,
|
||||
IReadOnlyDictionary<string, object?> data,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var payload = new Dictionary<string, object?>(data.Count + 1)
|
||||
{
|
||||
["event"] = eventName,
|
||||
};
|
||||
|
||||
foreach (var (key, value) in data)
|
||||
{
|
||||
payload[key] = value;
|
||||
}
|
||||
|
||||
await WriteLineAsync(writer, payload, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private static async Task WriteLineAsync(
|
||||
TextWriter writer,
|
||||
IReadOnlyDictionary<string, object?> payload,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
var json = JsonSerializer.Serialize(payload, SerializerOptions);
|
||||
await writer.WriteLineAsync(json.AsMemory(), cancellationToken).ConfigureAwait(false);
|
||||
await writer.FlushAsync(cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user