HTTP: получить JSON, проверить ответ и отменить запрос

using Reckfell;

public partial class HttpJsonDemo : Entity
{
    [Export] public string Url { get; set; } = "http://127.0.0.1:8765/message";
    public override void _Ready()
    {
        var api = new HttpJsonRequest(); AddChild(api);
        api.Completed += reply => ReckfellApi.Print($"HTTP: transport={reply.Transport}, status={reply.StatusCode}, failure={reply.Failure}, message={reply.Message}");
        Error start = api.Start(Url);
        if (start != Error.Ok) ReckfellApi.Print($"HTTP start: {start}");
    }
}

using System;
using System.Text.Json;
using Reckfell;

public partial class HttpJsonRequest : Entity
{
    public sealed record Reply(HttpRequest.Result Transport, int StatusCode, string Message, string Failure)
    {
        public bool IsSuccess => Failure.Length == 0;
    }
    public int MaxBytes { get; set; } = 65536;
    public double TimeoutSeconds { get; set; } = 5;
    public bool UseThreads { get; set; }
    public TlsOptions? Trust { get; set; }
    public bool Busy => _active is not null;
    public Reply? LastReply { get; private set; }
    public event Action<Reply>? Completed;
    private HttpRequest? _active;

    public Error Start(string url, HttpClient.Method method = HttpClient.Method.Get, string jsonBody = "")
    {
        if (Busy) return Error.Busy;
        if (!IsInsideTree()) return Error.Unconfigured;
        if (!Uri.TryCreate(url, UriKind.Absolute, out Uri? uri) ||
            (uri.Scheme != "http" && uri.Scheme != "https") || uri.UserInfo.Length != 0 ||
            MaxBytes <= 0 || !double.IsFinite(TimeoutSeconds) || TimeoutSeconds <= 0)
            return Error.InvalidParameter;
        var request = new HttpRequest { BodySizeLimit = MaxBytes, Timeout = TimeoutSeconds, MaxRedirects = 0, UseThreads = UseThreads };
        if (Trust is not null) request.SetTlsOptions(Trust);
        _active = request; LastReply = null; AddChild(request);
        request.RequestCompleted += (result, code, headers, body) =>
        {
            if (_active != request) return;
            _active = null;
            var transport = (HttpRequest.Result)result;
            Reply reply;
            if (transport != HttpRequest.Result.Success) reply = new(transport, (int)code, "", "transport");
            else if (code < 200 || code >= 300) reply = new(transport, (int)code, "", "http");
            else
            {
                try
                {
                    using JsonDocument doc = JsonDocument.Parse(body);
                    if (doc.RootElement.ValueKind == JsonValueKind.Object &&
                        doc.RootElement.TryGetProperty("message", out JsonElement value) &&
                        value.ValueKind == JsonValueKind.String && value.GetString() is string message && message.Length <= 128)
                        reply = new(transport, (int)code, message, "");
                    else reply = new(transport, (int)code, "", "schema");
                }
                catch (JsonException) { reply = new(transport, (int)code, "", "json"); }
            }
            LastReply = reply; request.QueueFree(); Completed?.Invoke(reply);
        };
        string[] headers = jsonBody.Length == 0 ? ["Accept: application/json"] :
            ["Accept: application/json", "Content-Type: application/json; charset=utf-8"];
        Error error = request.Request(url, headers, method, jsonBody);
        if (error != Error.Ok) { _active = null; request.CancelRequest(); request.QueueFree(); }
        return error;
    }
    public void Cancel()
    {
        HttpRequest? request = _active; _active = null;
        if (request is null) return;
        request.CancelRequest(); request.QueueFree();
    }
    public override void _ExitTree() => Cancel();
}

"""A loopback-only HTTP fixture. Python 3 standard library; no production data."""
import gzip
import json
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer


class Handler(BaseHTTPRequestHandler):
    protocol_version = 'HTTP/1.1'

    def log_message(self, *args):
        pass

    def handle(self):
        try:
            super().handle()
        except ConnectionError:
            self.close_connection = True

    def reply(self, status, body, headers=None):
        self.send_response(status)
        self.send_header('Content-Type', 'application/json; charset=utf-8')
        self.send_header('Content-Length', str(len(body)))
        for name, value in (headers or {}).items():
            self.send_header(name, value)
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        body = json.dumps({'message': 'Привет 🌍'}, ensure_ascii=False).encode('utf-8')
        path = self.path.split('?', 1)[0]
        try:
            if path == '/slow':
                time.sleep(0.5)
            if path == '/missing':
                self.reply(404, b'{"error":"missing"}')
            elif path == '/bad-json':
                self.reply(200, b'{')
            elif path == '/wrong-schema':
                self.reply(200, b'{"message":42}')
            elif path == '/empty':
                self.reply(204, b'')
            elif path == '/large':
                self.reply(200, b'x' * 70000)
            elif path == '/gzip':
                self.reply(200, gzip.compress(body), {'Content-Encoding': 'gzip'})
            elif path == '/gzip-large':
                self.reply(200, gzip.compress(b'x' * 70000), {'Content-Encoding': 'gzip'})
            elif path == '/redirect':
                self.reply(302, b'', {'Location': '/message'})
            elif path in ('/chunked', '/eof', '/truncated'):
                self.send_response(200)
                self.send_header('Content-Type', 'application/json; charset=utf-8')
                if path == '/chunked':
                    self.send_header('Transfer-Encoding', 'chunked')
                elif path == '/truncated':
                    self.send_header('Content-Length', str(len(body) + 20))
                else:
                    self.send_header('Connection', 'close')
                self.end_headers()
                if path == '/chunked':
                    for start in range(0, len(body), 4):
                        chunk = body[start:start + 4]
                        self.wfile.write(f'{len(chunk):X}\r\n'.encode() + chunk + b'\r\n')
                    self.wfile.write(b'0\r\n\r\n')
                else:
                    self.wfile.write(body)
                    self.close_connection = True
            else:
                self.reply(200, body)
        except ConnectionError:
            self.close_connection = True

    def do_POST(self):
        length = int(self.headers.get('Content-Length', '0'))
        if length > 65536:
            self.reply(413, b'{}')
            self.close_connection = True
            return
        self.reply(200, self.rfile.read(length))


def create_server(port=8765):
    server = ThreadingHTTPServer(('127.0.0.1', port), Handler)
    server.daemon_threads = True
    return server


if __name__ == '__main__':
    with create_server() as server:
        print('HTTP fixture: http://127.0.0.1:8765/message', flush=True)
        try:
            server.serve_forever()
        except KeyboardInterrupt:
            pass