feat(networking): introduce message-oriented networking transports

Directory.Packages.props

@@ -40,7 +40,6 @@
     <PackageVersion Include="MessagePack" Version="3.1.7" />
     <PackageVersion Include="Microsoft.NET.StringTools" Version="17.11.4" />
     <PackageVersion Include="Microsoft.Accordant" Version="0.1.6" />
-    <PackageVersion Include="Microsoft.AspNetCore.Connections.Abstractions" Version="8.0.24" />
     <PackageVersion Include="Microsoft.Azure.Cosmos" Version="3.57.0" />
     <PackageVersion Include="Microsoft.Build" Version="17.10.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.9.0" />
@@ -147,7 +146,6 @@
     <PackageVersion Update="Aspire.StackExchange.Redis" Version="13.2.4" />
     <PackageVersion Update="BenchmarkDotNet" Version="0.15.6" />
     <PackageVersion Update="FSharp.Core" Version="10.0.103" />
-    <PackageVersion Update="Microsoft.AspNetCore.Connections.Abstractions" Version="10.0.3" />
     <PackageVersion Update="Microsoft.CodeAnalysis.Common" Version="5.0.0" />
     <PackageVersion Update="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="5.0.0" />
     <PackageVersion Update="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />

Orleans.slnx

@@ -70,7 +70,6 @@
   <Folder Name="/src/Extensions/">
     <Project Path="src/Orleans.Clustering.Consul/Orleans.Clustering.Consul.csproj" />
     <Project Path="src/Orleans.Clustering.ZooKeeper/Orleans.Clustering.ZooKeeper.csproj" />
-    <Project Path="src/Orleans.Connections.Security/Orleans.Connections.Security.csproj" />
     <Project Path="src/Orleans.Hosting.Kubernetes/Orleans.Hosting.Kubernetes.csproj" />
   </Folder>
   <Folder Name="/src/Extensions/AdoNet/">

docs/site/src/content/docs/host/connection-middleware.md

@@ -1,55 +1,55 @@
 ---
-title: Connection middleware
-description: Plug custom logic, such as authentication or custom framing, into Orleans silo-to-silo and client-to-silo connections.
-ms.date: 08/11/2026
+title: Message transport middleware
+description: Decorate Orleans message transport connectors and listeners with cross-cutting connection behavior.
+ms.date: 08/21/2026
 ms.topic: how-to
 ---
 
-# Connection middleware
+# Message transport middleware
 
-Orleans silo-to-silo and client-to-gateway connections are built from a chain of middleware, similar to an ASP.NET Core request pipeline. <xref:Orleans.Runtime.Messaging.IConnectionMiddleware> lets you insert custom logic, such as authentication, custom framing, or connection-level diagnostics, into that pipeline without reimplementing connection setup.
+Orleans establishes silo-to-silo and client-to-gateway connections through message transport connectors and listeners. Transport middleware decorates those components before they create or accept a connection.
 
-Orleans itself uses this abstraction for TLS. See [Secure Orleans connections with TLS](transport-layer-security.md) for the built-in TLS middleware.
+<xref:Orleans.Connections.Transport.IMessageTransportConnectorMiddleware> applies to outbound connectors. <xref:Orleans.Connections.Transport.IMessageTransportListenerMiddleware> applies to inbound listeners. Orleans applies every registered middleware instance in dependency-injection registration order.
 
-## The middleware interface
-
-The interface defines `OnConnectionAsync(ConnectionContext, ConnectionDelegate)`. A middleware instance can be invoked concurrently for multiple connections, so store per-connection state in local variables or on the <xref:Microsoft.AspNetCore.Connections.ConnectionContext>, not on the middleware instance. Implementations should call `next(context)` to continue the pipeline after performing their work; not calling `next` terminates the connection.
+Orleans uses transport middleware to apply TLS. See [Secure Orleans connections with TLS](transport-layer-security.md) for the built-in security configuration.
 
 ## Register middleware
 
-Use <xref:Orleans.ConnectionMiddlewareExtensions.UseMiddleware*> on an <xref:Microsoft.AspNetCore.Connections.IConnectionBuilder> to add middleware to a connection pipeline:
+Register connector and listener middleware as singleton services:
 
 :::code language="csharp" source="./snippets/connection-middleware/ConnectionMiddlewareExamples.cs" id="RegisterMiddleware":::
 
-Connection pipelines are configured through <xref:Orleans.Configuration.SiloConnectionOptions> (silo) and <xref:Orleans.Configuration.ClientConnectionOptions> (client). A silo has three distinct pipelines:
+The middleware instances can be invoked for multiple connectors or listeners, so keep per-connection state in the returned decorator or the resulting <xref:Orleans.Connections.Transport.MessageTransport>.
+
+## Decorate outbound connectors
 
-:::code language="csharp" source="./snippets/connection-middleware/ConnectionMiddlewareExamples.cs" id="SiloPipelines":::
+A connector middleware receives the next <xref:Orleans.Connections.Transport.MessageTransportConnector> and returns the connector Orleans should use. The decorator can observe connection attempts, select another transport, or wrap the returned message transport:
 
-An Orleans client has a single outbound pipeline, configured with <xref:Orleans.Configuration.ClientConnectionOptions>:
+:::code language="csharp" source="./snippets/connection-middleware/ConnectionMiddlewareExamples.cs" id="ConnectorDecorator":::
 
-:::code language="csharp" source="./snippets/connection-middleware/ConnectionMiddlewareExamples.cs" id="ClientPipeline":::
+Delegate <xref:Orleans.Connections.Transport.MessageTransportConnector.Features>, `IsValid`, and disposal unless the middleware deliberately changes those guarantees.
 
-Middleware added first runs first, wrapping every middleware added after it, matching the order `UseMiddleware` is called. Register the middleware type itself (for example `MyClientSideMiddleware`, `MyServerSideMiddleware`) as a singleton service when using the generic `UseMiddleware<T>()` overload.
+Orleans owns the connector decorators returned by middleware. During host disposal, the connection factory closes connection-establishment admission, awaits admitted attempts, and disposes the decorated connector chain. Each decorator disposes its own resources and delegates disposal to its inner connector. The service provider owns the registered transport connector and disposes it separately.
 
-> [!NOTE]
-> Silo-to-silo and client-to-silo connections perform an Orleans-internal handshake after the connection pipeline runs. Middleware that terminates or replaces the transport (such as TLS) must leave a working `ConnectionContext` in place before calling `next`, because Orleans handshake and message framing execute afterward.
+## Decorate inbound listeners
 
-## Read and write framed data
+A listener middleware receives the next <xref:Orleans.Connections.Transport.MessageTransportListener> and returns the listener Orleans should bind and accept from:
 
-Custom middleware that exchanges its own protocol data before calling `next` (for example, a handshake) can read and write directly from `context.Transport.Input`/`Output` (`PipeReader`/`PipeWriter`), or use <xref:Orleans.Runtime.Messaging.ConnectionFrameHelper> for structured, length-prefixed frames. `ConnectionFrameHelper` is optional; it exists to save middleware authors from re-implementing length-prefixed framing.
+:::code language="csharp" source="./snippets/connection-middleware/ConnectionMiddlewareExamples.cs" id="ListenerDecorator":::
 
-The wire format per frame is `[4-byte little-endian length][1-byte frame type][payload]`, where the length equals `1 + payload.Length`.
+Preserve the listener name so Orleans can select the silo and gateway listeners by role. Return `null` from `AcceptAsync` when the inner listener has stopped, matching the listener contract.
 
-:::code language="csharp" source="./snippets/connection-middleware/ConnectionMiddlewareExamples.cs" id="ServerMiddleware":::
+## Migrate byte-stream middleware
 
-`ConnectionFrameHelper` also provides `WriteLengthPrefixedString`/`ReadLengthPrefixedString` helpers for encoding UTF-8 strings inside a frame payload, and a zero-copy `WriteFrameAsync` overload that writes the payload directly into the transport pipe buffer via an `Action<IBufferWriter<byte>>` delegate, avoiding an intermediate `byte[]` allocation.
+Customizations previously registered through `ClientConnectionOptions`, `SiloConnectionOptions`, or `IConnectionMiddleware` migrate to the connector and listener decorators shown above. Register outbound behavior as connector middleware and inbound behavior as listener middleware. Listener decorators can use the listener name to configure the `silo` and `gateway` roles independently.
 
-`ReadFrameAsync` throws `InvalidOperationException` if the connection is closed mid-frame or if the declared frame length exceeds `maxFrameLength` (`ConnectionFrameHelper.DefaultMaxFrameLength`, 1 MB, by default). Pass a smaller `maxFrameLength` if your protocol's frames are bounded more tightly, to fail fast on malformed or hostile input.
+The message transport request contracts own framing, completion, and buffer lifetimes. Decorators preserve those contracts while applying per-connection behavior.
 
 ## See also
 
-- <xref:Orleans.Runtime.Messaging.IConnectionMiddleware>
-- <xref:Orleans.Runtime.Messaging.ConnectionFrameHelper>
+- <xref:Orleans.Connections.Transport.MessageTransport>
+- <xref:Orleans.Connections.Transport.MessageTransportConnector>
+- <xref:Orleans.Connections.Transport.MessageTransportListener>
 - [Secure Orleans connections with TLS](transport-layer-security.md)
 - [Server configuration](configuration-guide/server-configuration.md)
 - [Client configuration](configuration-guide/client-configuration.md)

docs/site/src/content/docs/host/snippets/connection-middleware/ConnectionMiddlewareExamples.cs

@@ -1,128 +1,84 @@
-using System.Text;
-using Microsoft.AspNetCore.Connections;
+using System.Net;
 using Microsoft.Extensions.DependencyInjection;
-using Orleans;
-using Orleans.Configuration;
-using Orleans.Hosting;
-using Orleans.Runtime.Messaging;
+using Microsoft.Extensions.Logging;
+using Orleans.Connections.Transport;
 
 namespace ConnectionMiddlewareSnippets;
 
 internal static class ConnectionMiddlewareExamples
 {
     // <RegisterMiddleware>
-    public static void RegisterFromDependencyInjection(
-        IServiceCollection services,
-        IConnectionBuilder connectionBuilder)
+    public static void RegisterTransportMiddleware(IServiceCollection services)
     {
-        services.AddSingleton<MyClientSideMiddleware>();
-        connectionBuilder.UseMiddleware<MyClientSideMiddleware>();
-    }
-
-    public static void RegisterInstance(IConnectionBuilder connectionBuilder)
-    {
-        // The caller owns this shared instance and is responsible for disposing it.
-        connectionBuilder.UseMiddleware(new MyClientSideMiddleware());
+        services.AddSingleton<IMessageTransportConnectorMiddleware, LoggingConnectorMiddleware>();
+        services.AddSingleton<IMessageTransportListenerMiddleware, LoggingListenerMiddleware>();
     }
     // </RegisterMiddleware>
+}
 
-    // <SiloPipelines>
-    public static void ConfigureSilo(ISiloBuilder siloBuilder)
-    {
-        siloBuilder.Services.AddSingleton<MyClientSideMiddleware>();
-        siloBuilder.Services.AddSingleton<MyServerSideMiddleware>();
-
-        siloBuilder.Configure<SiloConnectionOptions>(options =>
-        {
-            // Connections this silo makes to other silos.
-            options.ConfigureSiloOutboundConnection(connectionBuilder =>
-            {
-                connectionBuilder.UseMiddleware<MyClientSideMiddleware>();
-            });
+internal sealed class LoggingConnectorMiddleware(ILoggerFactory loggerFactory)
+    : IMessageTransportConnectorMiddleware
+{
+    public MessageTransportConnector Apply(MessageTransportConnector transport) =>
+        new LoggingConnector(transport, loggerFactory.CreateLogger<LoggingConnector>());
+}
 
-            // Connections this silo accepts from other silos.
-            options.ConfigureSiloInboundConnection(connectionBuilder =>
-            {
-                connectionBuilder.UseMiddleware<MyServerSideMiddleware>();
-            });
+internal sealed class LoggingListenerMiddleware(ILoggerFactory loggerFactory)
+    : IMessageTransportListenerMiddleware
+{
+    public MessageTransportListener Apply(MessageTransportListener listener) =>
+        new LoggingListener(listener, loggerFactory.CreateLogger<LoggingListener>());
+}
 
-            // Connections this silo accepts from Orleans clients through the gateway.
-            options.ConfigureGatewayInboundConnection(connectionBuilder =>
-            {
-                connectionBuilder.UseMiddleware<MyServerSideMiddleware>();
-            });
-        });
-    }
-    // </SiloPipelines>
+// <ConnectorDecorator>
+internal sealed class LoggingConnector(
+    MessageTransportConnector inner,
+    ILogger<LoggingConnector> logger) : MessageTransportConnector
+{
+    public override IFeatureCollection Features => inner.Features;
+    public override bool IsValid => inner.IsValid;
 
-    // <ClientPipeline>
-    public static void ConfigureClient(IClientBuilder clientBuilder)
+    public override async ValueTask<MessageTransport> CreateAsync(
+        EndPoint endpoint,
+        CancellationToken cancellationToken = default)
     {
-        clientBuilder.Services.AddSingleton<MyClientSideMiddleware>();
-
-        clientBuilder.Configure<ClientConnectionOptions>(options =>
-        {
-            options.ConfigureConnection(connectionBuilder =>
-            {
-                connectionBuilder.UseMiddleware<MyClientSideMiddleware>();
-            });
-        });
+        logger.LogInformation("Connecting Orleans transport to {Endpoint}", endpoint);
+        return await inner.CreateAsync(endpoint, cancellationToken);
     }
-    // </ClientPipeline>
+
+    public override ValueTask DisposeAsync() => inner.DisposeAsync();
 }
+// </ConnectorDecorator>
 
-internal sealed class MyClientSideMiddleware : IConnectionMiddleware
+// <ListenerDecorator>
+internal sealed class LoggingListener(
+    MessageTransportListener inner,
+    ILogger<LoggingListener> logger) : MessageTransportListener
 {
-    public async Task OnConnectionAsync(
-        ConnectionContext context,
-        ConnectionDelegate next)
-    {
-        var requestPayload = Encoding.UTF8.GetBytes("hello");
-        await ConnectionFrameHelper.WriteFrameAsync(
-            context, frameType: 0x01, requestPayload, context.ConnectionClosed);
+    public override bool IsValid => inner.IsValid;
+    public override string ListenerName => inner.ListenerName;
+    public override IFeatureCollection Features => inner.Features;
 
-        var (frameType, payload) = await ConnectionFrameHelper.ReadFrameAsync(
-            context, context.ConnectionClosed);
+    public override ValueTask BindAsync(CancellationToken cancellationToken = default) =>
+        inner.BindAsync(cancellationToken);
 
-        if (frameType != 0x02
-            || !string.Equals(
-                Encoding.UTF8.GetString(payload),
-                "ok",
-                StringComparison.Ordinal))
+    public override async ValueTask<MessageTransport?> AcceptAsync(
+        CancellationToken cancellationToken = default)
+    {
+        var transport = await inner.AcceptAsync(cancellationToken);
+        if (transport is not null)
         {
-            throw new InvalidOperationException("Unexpected handshake response.");
+            logger.LogInformation(
+                "Accepted Orleans transport on listener {ListenerName}",
+                ListenerName);
         }
 
-        await next(context);
+        return transport;
     }
-}
 
-// <ServerMiddleware>
-internal sealed class MyServerSideMiddleware : IConnectionMiddleware
-{
-    public async Task OnConnectionAsync(
-        ConnectionContext context,
-        ConnectionDelegate next)
-    {
-        // Read one frame of the custom handshake protocol.
-        var (frameType, payload) = await ConnectionFrameHelper.ReadFrameAsync(
-            context, context.ConnectionClosed);
-
-        if (frameType != 0x01
-            || !string.Equals(
-                Encoding.UTF8.GetString(payload),
-                "hello",
-                StringComparison.Ordinal))
-        {
-            throw new InvalidOperationException("Unexpected handshake request.");
-        }
-
-        var responsePayload = Encoding.UTF8.GetBytes("ok");
-        await ConnectionFrameHelper.WriteFrameAsync(
-            context, frameType: 0x02, responsePayload, context.ConnectionClosed);
+    public override ValueTask UnbindAsync(CancellationToken cancellationToken = default) =>
+        inner.UnbindAsync(cancellationToken);
 
-        // Continue the pipeline; Orleans's own handshake and framing run after this.
-        await next(context);
-    }
+    public override ValueTask DisposeAsync() => inner.DisposeAsync();
 }
-// </ServerMiddleware>
+// </ListenerDecorator>

docs/site/src/content/docs/host/snippets/transport-layer-security/csharp/ClientExample/ClientExample.csproj

@@ -5,11 +5,11 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <RepositoryRoot>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..\..\..\..\..\..\..\..\..\..\'))</RepositoryRoot>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Orleans.Client" Version="10.2.2" />
-    <PackageReference Include="Microsoft.Orleans.Connections.Security" Version="10.2.2" />
+    <ProjectReference Include="$(RepositoryRoot)src\Orleans.Client\Orleans.Client.csproj" />
   </ItemGroup>
 
 </Project>

docs/site/src/content/docs/host/snippets/transport-layer-security/csharp/ClientExample/Program.cs

@@ -1,6 +1,6 @@
 using System.Security.Cryptography.X509Certificates;
 using Microsoft.Extensions.Hosting;
-using Orleans.Connections.Security;
+using Orleans.Connections.Transport.Security;
 using Orleans.Hosting;
 
 Console.WriteLine("TLS configuration examples");

docs/site/src/content/docs/host/snippets/transport-layer-security/csharp/SiloExample/Program.cs

@@ -1,6 +1,6 @@
 using System.Security.Cryptography.X509Certificates;
 using Microsoft.Extensions.Hosting;
-using Orleans.Connections.Security;
+using Orleans.Connections.Transport.Security;
 using Orleans.Hosting;
 
 Console.WriteLine("TLS configuration examples");

docs/site/src/content/docs/host/snippets/transport-layer-security/csharp/SiloExample/SiloExample.csproj

@@ -5,11 +5,11 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <RepositoryRoot>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..\..\..\..\..\..\..\..\..\..\'))</RepositoryRoot>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Orleans.Connections.Security" Version="10.2.2" />
-    <PackageReference Include="Microsoft.Orleans.Server" Version="10.2.2" />
+    <ProjectReference Include="$(RepositoryRoot)src\Orleans.Server\Orleans.Server.csproj" />
   </ItemGroup>
 
 </Project>