Files
EonaCat.Connections/EonaCat.Connections/Helpers/HealthApiServer.cs
T
2026-11-04 07:53:40 +01:00

341 lines
11 KiB
C#

using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Diagnostics;
namespace EonaCat.Connections.Helpers
{
public class HealthApiServer : IDisposable
{
private TcpListener _listener;
private CancellationTokenSource _cts;
private Task _listenTask;
private volatile bool _running;
private readonly Func<string> _getHealthJson;
private readonly Func<string> _getStatusJson;
public int Port { get; private set; }
public bool IsRunning => _running;
public bool IsSharedPort { get; private set; }
internal static string GetProcessName()
{
using (var process = Process.GetCurrentProcess())
{
return process.ProcessName;
}
}
internal void StartSharedPort(int port)
{
if (_running && !IsSharedPort)
{
throw new InvalidOperationException("The health API is already using a separate listener.");
}
Port = port;
IsSharedPort = true;
_running = true;
}
public HealthApiServer(Func<string> getHealthJson, Func<string> getStatusJson)
{
_getHealthJson = getHealthJson ?? throw new ArgumentNullException(nameof(getHealthJson));
_getStatusJson = getStatusJson ?? throw new ArgumentNullException(nameof(getStatusJson));
}
public void Start(int port = 0, IPAddress bindAddress = null)
{
if (_running)
{
return;
}
_cts?.Dispose();
_cts = new CancellationTokenSource();
_running = true;
_listener = new TcpListener(bindAddress ?? IPAddress.Loopback, port);
_listener.Start();
Port = ((IPEndPoint)_listener.LocalEndpoint).Port;
var token = _cts.Token;
_listenTask = Task.Run(async () => await AcceptLoopAsync(token).ConfigureAwait(false), token);
}
public void Stop()
{
if (!_running)
{
return;
}
_running = false;
_cts?.Cancel();
try
{
_listener?.Stop();
}
catch (Exception)
{
}
try
{
_listenTask?.Wait(TimeSpan.FromSeconds(5));
}
catch (AggregateException)
{
}
Port = 0;
IsSharedPort = false;
}
private async Task AcceptLoopAsync(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
TcpClient client = null;
try
{
client = await _listener.AcceptTcpClientAsync().ConfigureAwait(false);
HandlingHelpers.SafeFireAndForgetTaskAsync(
() => HandleRequestAsync(client),
"HealthApiServer.HandleRequest");
}
catch (ObjectDisposedException)
{
break;
}
catch (SocketException)
{
break;
}
catch (Exception)
{
}
}
}
private async Task HandleRequestAsync(TcpClient client)
{
try
{
using (client)
{
client.ReceiveTimeout = 5000;
client.SendTimeout = 5000;
using var stream = client.GetStream();
await HandleRequestAsync(stream).ConfigureAwait(false);
}
}
catch (Exception)
{
}
}
internal async Task HandleRequestAsync(Stream stream, bool allowAccess = true)
{
var requestLine = await ReadRequestLineAsync(stream).ConfigureAwait(false);
if (string.IsNullOrEmpty(requestLine))
{
await WriteResponseAsync(stream, 400, "Bad Request", "text/plain", "Bad Request").ConfigureAwait(false);
return;
}
var parts = requestLine.Split(' ');
if (parts.Length < 2)
{
await WriteResponseAsync(stream, 400, "Bad Request", "text/plain", "Bad Request").ConfigureAwait(false);
return;
}
var method = parts[0].ToUpperInvariant();
var path = parts[1].Split('?')[0].TrimEnd('/').ToLowerInvariant();
await DrainHeadersAsync(stream).ConfigureAwait(false);
if (!allowAccess)
{
await WriteResponseAsync(stream, 403, "Forbidden", "text/plain", "Forbidden").ConfigureAwait(false);
return;
}
if (method != "GET")
{
await WriteResponseAsync(stream, 405, "Method Not Allowed", "text/plain", "Method Not Allowed").ConfigureAwait(false);
return;
}
switch (path)
{
case "" or "/":
var indexJson = "{\"endpoints\":[\"/health\",\"/status\",\"/dashboard\"]}";
await WriteResponseAsync(stream, 200, "OK", "application/json", indexJson).ConfigureAwait(false);
break;
case "/dashboard":
using (var resource = typeof(HealthApiServer).Assembly.GetManifestResourceStream("EonaCat.Connections.Helpers.TrafficDashboard.html")
?? throw new InvalidOperationException("The traffic dashboard resource is missing."))
using (var reader = new StreamReader(resource, Encoding.UTF8))
{
await WriteResponseAsync(stream, 200, "OK", "text/html", reader.ReadToEnd()).ConfigureAwait(false);
}
break;
case "/health":
var healthJson = SafeGetJson(_getHealthJson);
await WriteResponseAsync(stream, 200, "OK", "application/json", healthJson).ConfigureAwait(false);
break;
case "/status":
var statusJson = SafeGetJson(_getStatusJson);
await WriteResponseAsync(stream, 200, "OK", "application/json", statusJson).ConfigureAwait(false);
break;
default:
await WriteResponseAsync(stream, 404, "Not Found", "text/plain", "Not Found").ConfigureAwait(false);
break;
}
}
private static string SafeGetJson(Func<string> getter)
{
try
{
return getter() ?? "{}";
}
catch (Exception ex)
{
return "{\"error\":" + JsonEscape(ex.Message) + "}";
}
}
private static async Task<string> ReadRequestLineAsync(Stream stream)
{
var sb = new StringBuilder();
var buffer = new byte[1];
var prev = (byte)0;
while (sb.Length < 8192)
{
int read = await stream.ReadAsync(buffer, 0, 1).ConfigureAwait(false);
if (read == 0)
{
break;
}
var b = buffer[0];
if (b == (byte)'\n')
{
break;
}
if (b != (byte)'\r')
{
sb.Append((char)b);
}
prev = b;
}
return sb.ToString();
}
private static async Task DrainHeadersAsync(Stream stream)
{
var sb = new StringBuilder();
var buffer = new byte[1];
int consecutiveNewlines = 0;
while (consecutiveNewlines < 2)
{
int read = await stream.ReadAsync(buffer, 0, 1).ConfigureAwait(false);
if (read == 0)
{
break;
}
if (buffer[0] == (byte)'\n')
{
consecutiveNewlines++;
}
else if (buffer[0] != (byte)'\r')
{
consecutiveNewlines = 0;
}
}
}
private static async Task WriteResponseAsync(Stream stream, int statusCode, string statusText, string contentType, string body)
{
var bodyBytes = Encoding.UTF8.GetBytes(body);
var header = $"HTTP/1.1 {statusCode} {statusText}\r\n" +
$"Content-Type: {contentType}; charset=utf-8\r\n" +
$"Content-Length: {bodyBytes.Length}\r\n" +
"Access-Control-Allow-Origin: *\r\n" +
"Connection: close\r\n" +
"X-Content-Type-Options: nosniff\r\n" +
"Cache-Control: no-store\r\n" +
"\r\n";
var headerBytes = Encoding.ASCII.GetBytes(header);
await stream.WriteAsync(headerBytes, 0, headerBytes.Length).ConfigureAwait(false);
await stream.WriteAsync(bodyBytes, 0, bodyBytes.Length).ConfigureAwait(false);
await stream.FlushAsync().ConfigureAwait(false);
}
public static string JsonEscape(string value)
{
if (value == null)
{
return "null";
}
var sb = new StringBuilder(value.Length + 2);
sb.Append('"');
foreach (var c in value)
{
switch (c)
{
case '"': sb.Append("\\\""); break;
case '\\': sb.Append("\\\\"); break;
case '\b': sb.Append("\\b"); break;
case '\f': sb.Append("\\f"); break;
case '\n': sb.Append("\\n"); break;
case '\r': sb.Append("\\r"); break;
case '\t': sb.Append("\\t"); break;
default:
if (c < ' ')
{
sb.Append("\\u");
sb.Append(((int)c).ToString("x4"));
}
else
{
sb.Append(c);
}
break;
}
}
sb.Append('"');
return sb.ToString();
}
public void Dispose()
{
Stop();
_cts?.Dispose();
}
}
}