Rymote.Synapse.Net 1.0.0

Rymote.Synapse.Net

Mutually-authenticated TCP+TLS and QUIC transports for Rymote.Synapse.

What it provides

• ITransport implementations for TCP+TLS (Rymote.Synapse.Net.Tcp.TcpTransport) and QUIC (Rymote.Synapse.Net.Quic.QuicTransport).
• IStream abstraction (declared in Rymote.Synapse.Abstractions) for multiplexed bidirectional streams within a connection.
• Unified frame codec (length-prefixed binary; FrameKind + StreamId + payload).
• MessagePack handshake protocol with protocol-version, node-identity, and capability negotiation.
• Heartbeat-based liveness detection (Ping/Pong on stream 0).
• DI extensions: .UseTcpTransport(...) and .UseQuicTransport(...).

What it doesn't do

• Reconnect. Connections are single-use. Rymote.Synapse.Cluster (forthcoming) handles reconnect with exponential backoff.
• Cluster membership. Same — Cluster's job.
• Pre-shared keys, application tokens. mTLS only.

Requirements

• TCP transport: any platform with TLS 1.3 support. .NET 10 defaults to TLS 1.3.
• QUIC transport: Windows 11 / Server 2022, or Linux with msquic installed. Throws PlatformNotSupportedException at construction on unsupported platforms.

Quickstart

ServiceCollection services = new();
services.AddLogging();

services.AddSynapse()
    .UseTcpTransport(options =>
    {
        options.ServerCertificate = LoadServerCert();
        options.ClientCertificate = LoadClientCert();
        options.CertificateValidationCallback = (sender, certificate, chain, errors) =>
        {
            // production: validate against your trust store
            return errors == System.Net.Security.SslPolicyErrors.None;
        };
    });

ServiceProvider provider = services.BuildServiceProvider();
ITransport transport = provider.GetRequiredService<ITransport>();

// Listen
await using IListener listener = await transport.ListenAsync(new IPEndPoint(IPAddress.Any, 8443), cancellationToken);
await foreach (IConnection connection in listener.AcceptAsync(cancellationToken))
{
    await foreach (IStream stream in connection.AcceptStreamsAsync(cancellationToken))
    {
        // handle stream
    }
}

// Or connect
await using IConnection connection = await transport.ConnectAsync(new IPEndPoint(serverAddress, 8443), cancellationToken);
await using IStream stream = await connection.OpenStreamAsync(cancellationToken);
await stream.SendAsync(payloadBytes, FrameKind.Data, cancellationToken);

For QUIC, replace .UseTcpTransport with .UseQuicTransport and the same options shape (plus ApplicationProtocols if customising ALPN).

Wire format

+--------+--------+--------+--------+--------+--------+--------+--------+--------+
|   uint32 length (big-endian)      | uint8  | uint32 stream id (big-endian)    |
+-----------------------------------+--------+----------------------------------+
|                                  payload                                      |
+-------------------------------------------------------------------------------+

• length counts: kind (1) + streamId (4) + payload bytes.
• Max frame size: 64 MiB by default; configurable via NetTransportOptions.MaxFrameSize.

Reserved stream IDs

• Stream 0: control (handshake, ping/pong, goodbye).
• Odd IDs (1, 3, 5, ...): initiator-opened streams.
• Even non-zero IDs (2, 4, 6, ...): acceptor-opened streams.