Restore Nightwing Move tracking witness
This commit is contained in:
parent
e85c05029c
commit
52a439842c
14 changed files with 1853 additions and 0 deletions
501
src/Mimir.EveSensorReceiver/Program.cs
Normal file
501
src/Mimir.EveSensorReceiver/Program.cs
Normal file
|
|
@ -0,0 +1,501 @@
|
|||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using MessagePack;
|
||||
using Mimir.Runtime.Synchronization;
|
||||
|
||||
var options = EveSensorReceiverOptions.Parse(args);
|
||||
using var receiver = new EveSensorReceiver(options);
|
||||
await receiver.RunAsync();
|
||||
|
||||
internal sealed record EveSensorReceiverOptions(
|
||||
int Port,
|
||||
string Path,
|
||||
string SourceId,
|
||||
string ExpectedType,
|
||||
string SubscribePath)
|
||||
{
|
||||
public static EveSensorReceiverOptions Parse(string[] args)
|
||||
{
|
||||
return new EveSensorReceiverOptions(
|
||||
ParseInt(args, "--port", 8793),
|
||||
ParseString(args, "--path", "/eve/camera"),
|
||||
ParseString(args, "--source-id", "eve-camera"),
|
||||
ParseString(args, "--type", "video-frame"),
|
||||
ParseString(args, "--subscribe-path", ParseString(args, "--path", "/eve/camera") + "/subscribe"));
|
||||
}
|
||||
|
||||
private static string ParseString(IReadOnlyList<string> args, string name, string fallback)
|
||||
{
|
||||
for (var index = 0; index < args.Count - 1; index++)
|
||||
{
|
||||
if (string.Equals(args[index], name, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return args[index + 1];
|
||||
}
|
||||
}
|
||||
|
||||
return fallback;
|
||||
}
|
||||
|
||||
private static int ParseInt(IReadOnlyList<string> args, string name, int fallback)
|
||||
{
|
||||
return int.TryParse(ParseString(args, name, ""), out var value) ? value : fallback;
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class EveSensorReceiver(EveSensorReceiverOptions options) : IDisposable
|
||||
{
|
||||
private readonly TcpListener listener = new(IPAddress.Any, options.Port);
|
||||
private readonly CancellationTokenSource stopping = new();
|
||||
private readonly ConcurrentDictionary<int, WebSocketSubscriber> subscribers = new();
|
||||
private int nextSubscriberId;
|
||||
|
||||
public async Task RunAsync()
|
||||
{
|
||||
listener.Start();
|
||||
Console.Error.WriteLine($"Eve sensor receiver listening on ws://0.0.0.0:{options.Port}{options.Path} source={options.SourceId}");
|
||||
while (!stopping.IsCancellationRequested)
|
||||
{
|
||||
var client = await listener.AcceptTcpClientAsync(stopping.Token).ConfigureAwait(false);
|
||||
_ = Task.Run(() => HandleAsync(client));
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleAsync(TcpClient tcpClient)
|
||||
{
|
||||
await using var stream = tcpClient.GetStream();
|
||||
var request = await ReadHttpRequestAsync(stream).ConfigureAwait(false);
|
||||
if (request.Path == "/health")
|
||||
{
|
||||
var health = JsonSerializer.Serialize(new
|
||||
{
|
||||
ok = true,
|
||||
options.SourceId,
|
||||
options.ExpectedType,
|
||||
options.Path,
|
||||
options.SubscribePath,
|
||||
Subscribers = subscribers.Count,
|
||||
});
|
||||
await WriteHttpResponseAsync(stream, "200 OK", "application/json", Encoding.UTF8.GetBytes(health)).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (string.Equals(request.Path, options.SubscribePath, StringComparison.Ordinal)
|
||||
&& request.Headers.TryGetValue("Sec-WebSocket-Key", out var subscriberKey))
|
||||
{
|
||||
await WriteWebSocketHandshakeAsync(stream, subscriberKey).ConfigureAwait(false);
|
||||
await SubscribeAsync(stream).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!string.Equals(request.Path, options.Path, StringComparison.Ordinal)
|
||||
|| !request.Headers.TryGetValue("Sec-WebSocket-Key", out var key))
|
||||
{
|
||||
await WriteHttpResponseAsync(stream, "404 Not Found", "text/plain", Encoding.UTF8.GetBytes("not found")).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
|
||||
await WriteWebSocketHandshakeAsync(stream, key).ConfigureAwait(false);
|
||||
while (!stopping.IsCancellationRequested)
|
||||
{
|
||||
var frame = await ReceiveFrameAsync(stream).ConfigureAwait(false);
|
||||
if (frame.Opcode == 0x8)
|
||||
{
|
||||
await WriteCloseFrameAsync(stream).ConfigureAwait(false);
|
||||
break;
|
||||
}
|
||||
|
||||
if (frame.Opcode == 0x2)
|
||||
{
|
||||
if (TryValidateCultMeshObservation(frame.Payload, out var normalizedObservation)
|
||||
|| TryValidateCultMeshMediaObservation(frame.Payload, out normalizedObservation))
|
||||
{
|
||||
Console.WriteLine(normalizedObservation);
|
||||
Console.Out.Flush();
|
||||
await BroadcastAsync(normalizedObservation).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (frame.Opcode != 0x1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var text = Encoding.UTF8.GetString(frame.Payload);
|
||||
if (TryValidateFrameEvent(text, out var normalized))
|
||||
{
|
||||
Console.WriteLine(normalized);
|
||||
Console.Out.Flush();
|
||||
await BroadcastAsync(normalized).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task SubscribeAsync(NetworkStream stream)
|
||||
{
|
||||
var id = Interlocked.Increment(ref nextSubscriberId);
|
||||
var subscriber = new WebSocketSubscriber(id, stream);
|
||||
subscribers[id] = subscriber;
|
||||
Console.Error.WriteLine($"Eve sensor receiver subscriber {id} connected on {options.SubscribePath}.");
|
||||
try
|
||||
{
|
||||
await subscriber.SendTextAsync(JsonSerializer.Serialize(new
|
||||
{
|
||||
type = "mimir-verse-subscription",
|
||||
status = "connected",
|
||||
options.Path,
|
||||
options.SubscribePath,
|
||||
options.SourceId,
|
||||
options.ExpectedType,
|
||||
})).ConfigureAwait(false);
|
||||
|
||||
while (!stopping.IsCancellationRequested)
|
||||
{
|
||||
var frame = await ReceiveFrameAsync(stream).ConfigureAwait(false);
|
||||
if (frame.Opcode == 0x8)
|
||||
{
|
||||
await WriteCloseFrameAsync(stream).ConfigureAwait(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (IOException)
|
||||
{
|
||||
}
|
||||
catch (SocketException)
|
||||
{
|
||||
}
|
||||
finally
|
||||
{
|
||||
subscribers.TryRemove(id, out _);
|
||||
Console.Error.WriteLine($"Eve sensor receiver subscriber {id} disconnected.");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task BroadcastAsync(string normalized)
|
||||
{
|
||||
foreach (var pair in subscribers.ToArray())
|
||||
{
|
||||
try
|
||||
{
|
||||
await pair.Value.SendTextAsync(normalized).ConfigureAwait(false);
|
||||
}
|
||||
catch (IOException)
|
||||
{
|
||||
subscribers.TryRemove(pair.Key, out _);
|
||||
}
|
||||
catch (SocketException)
|
||||
{
|
||||
subscribers.TryRemove(pair.Key, out _);
|
||||
}
|
||||
catch (ObjectDisposedException)
|
||||
{
|
||||
subscribers.TryRemove(pair.Key, out _);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool TryValidateFrameEvent(string text, out string normalized)
|
||||
{
|
||||
normalized = "";
|
||||
try
|
||||
{
|
||||
using var document = JsonDocument.Parse(text);
|
||||
var root = document.RootElement;
|
||||
if (!root.TryGetProperty("type", out var type)
|
||||
|| !string.Equals(type.GetString(), options.ExpectedType, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.Equals(options.ExpectedType, "cultmesh-observation", StringComparison.OrdinalIgnoreCase)
|
||||
&& (!root.TryGetProperty("sourceId", out var sourceId)
|
||||
|| !string.Equals(sourceId.GetString(), options.SourceId, StringComparison.Ordinal)))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
normalized = root.GetRawText();
|
||||
return true;
|
||||
}
|
||||
catch (JsonException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private bool TryValidateCultMeshObservation(byte[] payload, out string normalized)
|
||||
{
|
||||
normalized = "";
|
||||
try
|
||||
{
|
||||
var observation = MessagePackSerializer.Deserialize<MimirEveSensorObservationDocument>(payload);
|
||||
if (!string.Equals(observation.StreamId, options.SourceId, StringComparison.Ordinal) &&
|
||||
!string.Equals(options.ExpectedType, "cultmesh-observation", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
normalized = JsonSerializer.Serialize(new
|
||||
{
|
||||
type = "cultmesh-observation",
|
||||
document = "mimir.eve_sensor_observation.v1",
|
||||
observation.ObservationId,
|
||||
observation.DeviceId,
|
||||
observation.StreamId,
|
||||
observation.Kind,
|
||||
observation.Sequence,
|
||||
observation.SensorTimestampNs,
|
||||
observation.ElapsedRealtimeNs,
|
||||
observation.WallClockUtc,
|
||||
observation.ClockDomainId,
|
||||
observation.Values,
|
||||
observation.Action,
|
||||
observation.PointerCount,
|
||||
observation.X,
|
||||
observation.Y,
|
||||
observation.Accuracy,
|
||||
});
|
||||
return true;
|
||||
}
|
||||
catch
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private bool TryValidateCultMeshMediaObservation(byte[] payload, out string normalized)
|
||||
{
|
||||
normalized = "";
|
||||
try
|
||||
{
|
||||
var observation = MessagePackSerializer.Deserialize<MimirEveMediaObservationDocument>(payload);
|
||||
if (!string.Equals(observation.StreamId, options.SourceId, StringComparison.Ordinal) &&
|
||||
!string.Equals(options.ExpectedType, "cultmesh-observation", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
normalized = JsonSerializer.Serialize(new
|
||||
{
|
||||
type = "cultmesh-media-observation",
|
||||
document = "mimir.eve_media_observation.v1",
|
||||
observation.ObservationId,
|
||||
observation.DeviceId,
|
||||
observation.StreamId,
|
||||
observation.Kind,
|
||||
observation.Sequence,
|
||||
observation.SensorTimestampNs,
|
||||
observation.ElapsedRealtimeNs,
|
||||
observation.WallClockUtc,
|
||||
observation.ClockDomainId,
|
||||
observation.Format,
|
||||
observation.Width,
|
||||
observation.Height,
|
||||
observation.SampleRate,
|
||||
observation.Channels,
|
||||
observation.FrameCount,
|
||||
observation.PayloadEncoding,
|
||||
PayloadBytes = observation.Payload.Length,
|
||||
});
|
||||
return true;
|
||||
}
|
||||
catch
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static async Task<HttpRequest> ReadHttpRequestAsync(NetworkStream stream)
|
||||
{
|
||||
var bytes = new List<byte>();
|
||||
var lastFour = new Queue<byte>(4);
|
||||
while (true)
|
||||
{
|
||||
var value = stream.ReadByte();
|
||||
if (value < 0)
|
||||
{
|
||||
throw new IOException("Client closed before HTTP headers completed.");
|
||||
}
|
||||
|
||||
var b = (byte)value;
|
||||
bytes.Add(b);
|
||||
lastFour.Enqueue(b);
|
||||
if (lastFour.Count > 4)
|
||||
{
|
||||
lastFour.Dequeue();
|
||||
}
|
||||
|
||||
if (lastFour.Count == 4 && lastFour.SequenceEqual(new byte[] { 13, 10, 13, 10 }))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
var text = Encoding.ASCII.GetString(bytes.ToArray());
|
||||
var lines = text.Split("\r\n", StringSplitOptions.None);
|
||||
var first = lines[0].Split(' ');
|
||||
var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
||||
foreach (var line in lines.Skip(1))
|
||||
{
|
||||
var colon = line.IndexOf(':');
|
||||
if (colon > 0)
|
||||
{
|
||||
headers[line[..colon].Trim()] = line[(colon + 1)..].Trim();
|
||||
}
|
||||
}
|
||||
|
||||
await Task.CompletedTask.ConfigureAwait(false);
|
||||
return new HttpRequest(first.Length > 1 ? first[1] : "/", headers);
|
||||
}
|
||||
|
||||
private static async Task WriteHttpResponseAsync(NetworkStream stream, string status, string contentType, byte[] body)
|
||||
{
|
||||
var header = Encoding.ASCII.GetBytes(
|
||||
$"HTTP/1.1 {status}\r\nContent-Type: {contentType}\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n");
|
||||
await stream.WriteAsync(header).ConfigureAwait(false);
|
||||
await stream.WriteAsync(body).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private static async Task WriteWebSocketHandshakeAsync(NetworkStream stream, string key)
|
||||
{
|
||||
var acceptBytes = SHA1.HashData(Encoding.ASCII.GetBytes(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
|
||||
var accept = Convert.ToBase64String(acceptBytes);
|
||||
var response = Encoding.ASCII.GetBytes(
|
||||
"HTTP/1.1 101 Switching Protocols\r\n" +
|
||||
"Upgrade: websocket\r\n" +
|
||||
"Connection: Upgrade\r\n" +
|
||||
$"Sec-WebSocket-Accept: {accept}\r\n\r\n");
|
||||
await stream.WriteAsync(response).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private static async Task<WebSocketFrame> ReceiveFrameAsync(NetworkStream stream)
|
||||
{
|
||||
var header = new byte[2];
|
||||
await ReadExactAsync(stream, header).ConfigureAwait(false);
|
||||
var opcode = header[0] & 0x0f;
|
||||
var masked = (header[1] & 0x80) != 0;
|
||||
var length = header[1] & 0x7f;
|
||||
if (length == 126)
|
||||
{
|
||||
var extended = new byte[2];
|
||||
await ReadExactAsync(stream, extended).ConfigureAwait(false);
|
||||
length = (extended[0] << 8) | extended[1];
|
||||
}
|
||||
else if (length == 127)
|
||||
{
|
||||
var extended = new byte[8];
|
||||
await ReadExactAsync(stream, extended).ConfigureAwait(false);
|
||||
var longLength = 0L;
|
||||
foreach (var b in extended)
|
||||
{
|
||||
longLength = (longLength << 8) | b;
|
||||
}
|
||||
|
||||
if (longLength > int.MaxValue)
|
||||
{
|
||||
throw new InvalidDataException("WebSocket frame is too large.");
|
||||
}
|
||||
|
||||
length = (int)longLength;
|
||||
}
|
||||
|
||||
var mask = new byte[4];
|
||||
if (masked)
|
||||
{
|
||||
await ReadExactAsync(stream, mask).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
var payload = new byte[length];
|
||||
await ReadExactAsync(stream, payload).ConfigureAwait(false);
|
||||
if (masked)
|
||||
{
|
||||
for (var index = 0; index < payload.Length; index++)
|
||||
{
|
||||
payload[index] ^= mask[index % 4];
|
||||
}
|
||||
}
|
||||
|
||||
return new WebSocketFrame(opcode, payload);
|
||||
}
|
||||
|
||||
private static Task WriteCloseFrameAsync(NetworkStream stream)
|
||||
{
|
||||
return stream.WriteAsync(new byte[] { 0x88, 0x00 }).AsTask();
|
||||
}
|
||||
|
||||
private static async Task ReadExactAsync(NetworkStream stream, byte[] buffer)
|
||||
{
|
||||
var offset = 0;
|
||||
while (offset < buffer.Length)
|
||||
{
|
||||
var read = await stream.ReadAsync(buffer.AsMemory(offset, buffer.Length - offset)).ConfigureAwait(false);
|
||||
if (read == 0)
|
||||
{
|
||||
throw new IOException("WebSocket closed.");
|
||||
}
|
||||
|
||||
offset += read;
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
stopping.Cancel();
|
||||
listener.Stop();
|
||||
stopping.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed record HttpRequest(string Path, IReadOnlyDictionary<string, string> Headers);
|
||||
|
||||
internal sealed record WebSocketFrame(int Opcode, byte[] Payload);
|
||||
|
||||
internal sealed class WebSocketSubscriber(int id, NetworkStream stream)
|
||||
{
|
||||
private readonly SemaphoreSlim writeLock = new(1, 1);
|
||||
|
||||
public int Id => id;
|
||||
|
||||
public async Task SendTextAsync(string text)
|
||||
{
|
||||
var payload = Encoding.UTF8.GetBytes(text);
|
||||
var header = new List<byte> { 0x81 };
|
||||
if (payload.Length < 126)
|
||||
{
|
||||
header.Add((byte)payload.Length);
|
||||
}
|
||||
else if (payload.Length <= ushort.MaxValue)
|
||||
{
|
||||
header.Add(126);
|
||||
header.Add((byte)(payload.Length >> 8));
|
||||
header.Add((byte)(payload.Length & 0xff));
|
||||
}
|
||||
else
|
||||
{
|
||||
header.Add(127);
|
||||
for (var shift = 56; shift >= 0; shift -= 8)
|
||||
{
|
||||
header.Add((byte)(((ulong)payload.Length >> shift) & 0xff));
|
||||
}
|
||||
}
|
||||
|
||||
await writeLock.WaitAsync().ConfigureAwait(false);
|
||||
try
|
||||
{
|
||||
await stream.WriteAsync(header.ToArray()).ConfigureAwait(false);
|
||||
await stream.WriteAsync(payload).ConfigureAwait(false);
|
||||
await stream.FlushAsync().ConfigureAwait(false);
|
||||
}
|
||||
finally
|
||||
{
|
||||
writeLock.Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue