341 lines
11 KiB
C#
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();
|
|
}
|
|
}
|
|
}
|