Using multiple proxies at once on the same stream

[Dylan Vos (ThaDaVos)]

Am I right that using multiple proxies on the same stream is not a supported scenario? I am getting "Unexpected Response" errors when I try to send an RPC from the second proxy - fyi, both proxies implement different interfaces.

---

EDIT: Some extra information:

In my application I have two interfaces:

[JsonRpcContract(), GenerateShape(IncludeMethods = MethodShapeFlags.PublicInstance)]
public partial interface IInterfaceA : IDisposable
{
    Task SomeMethodA();
}

[JsonRpcContract(), GenerateShape(IncludeMethods = MethodShapeFlags.PublicInstance)]
public partial interface IInterfaceB : IDisposable
{
    Task SomeMethodB();
}

Then I initialize the server as follows (this is in a background service for a MAUI application:

            while (!stoppingToken.IsCancellationRequested)
            {
                using NamedPipeServerStream pipestream = NamedPipeFactory.CreateNamedPipeServer();

                _logger.Information("Waiting for RPC client to connect...");

                await pipestream.WaitForConnectionAsync(stoppingToken);

                using JsonRpc rpc = new(pipestream)
                {
                    CancelLocallyInvokedMethodsWhenConnectionIsClosed = true
                };

                rpc.Disconnected += (sender, e) =>
                {
                    _logger.Information("RPC client disconnected. Message: {Message} Reason: {Reason}", e.Description, e.Reason);
                };

#if DEBUG
                rpc.TraceSource.Listeners.Add(new SerilogTraceListener.SerilogTraceListener(_logger));
#endif

                rpc.AddLocalRpcTarget<IInterfaceA>(new AService(_logger), new()
                {
                    ClientRequiresNamedArguments = true,
                    NotifyClientOfEvents = true,
                });

                rpc.AddLocalRpcTarget<IInterfaceB>(new BService(_logger), new()
                {
                    ClientRequiresNamedArguments = true,
                    NotifyClientOfEvents = true,
                });

                rpc.StartListening();
                _logger.Information("RPC client connected.");
                await rpc.Completion;
                _logger.Information("RPC client disconnected.");
            }

Now in my console app, I create two proxies as follows:

var namedPipeClientStream = NamedPipeFactory.CreateNamedPipeClient(autoConnect: true);
var proxyA = JsonRPC.Attach<IInterfaceA>(namedPipeClientStream);
var proxyB = JsonRPC.Attach<IInterfaceB>(namedPipeClientStream);

And have logic further on as:

await proxyA.SomeMethodA(); // This one runs fine, no error
await proxyB.SomeMethodB(); // Error, no connection

It seems after proxyA is called, the connection get's disconnected with the following logs:

[10:20:13 FTL] Connection closing (RemoteProtocolViolation: A response was received without a request having been sent.). null
[10:20:13 WRN] Disconnected from RPC server. Message: A response was received without a request having been sent. Reason: RemoteProtocolViolation
[10:20:13 WRN] Disconnected from RPC server. Message: Reached end of stream. Reason: RemotePartyTerminated
[10:20:13 WRN] Aborting pending request "3" because the connection was lost.

[Andrew Arnott (AArnott)]

Multiple proxies being used concurrently on the same connection is just fine. There must be some other explanation for the failures you're seeing.

[Dylan Vos (ThaDaVos)]

Multiple proxies of different interfaces? The "Disconnected" event gets triggered with as reason that it received a response without sending a request though

[Andrew Arnott (AArnott)]

Yes. Proxies are stateless. They just call JsonRpc methods underneath. You can just as easily have 50 proxies as you can make 50 individual RPC calls. And it's all thread safe as well.

Given the exception that is closing you dow, I expect the server is malfunctioning.
If you will add a tracesource object with verbose logging, you'll be able to see all the messages and get a better understanding of why it failed.

[Dylan Vos (ThaDaVos)]

I only see the following with TraceSource on the Client side:

Connection closing (RemoteProtocolViolation: A response was received without a request having been sent.). null

I also added more information to the initial post

[Dylan Vos (ThaDaVos)]

Got the TraceSource fully working now and it shows below:

RPC:ClientB Information: 8 : {"id":3,"method":"SomeMethodB"}
[11:52:00 INF] {"id":3,"method":"SomeMethodB"}
RPC:ClientB Verbose: 8 : Sent: {
  "jsonrpc": "2.0",
  "id": 3,
  "method": "SomeMethodB",
  "params": []
}
RPC:ClientA Information: 7 : {"id":3}
[11:52:01 INF] {"id":3}
RPC:ClientA Verbose: 7 : Received: {
  "jsonrpc": "2.0",
  "id": 3,
  "result": null
}
RPC:ClientA Information: 11 : Received result for request "3".
[11:52:01 INF] Received result for request "3".
RPC:ClientA Critical: 13 : Connection closing (RemoteProtocolViolation: A response was received without a request having been sent.). 

[Andrew Arnott (AArnott)]

This is the bug:

var proxyA = JsonRPC.Attach<IInterfaceA>(namedPipeClientStream);
var proxyB = JsonRPC.Attach<IInterfaceB>(namedPipeClientStream);

You're attaching two distinct JsonRpc instances to the same stream. That's broken. Frankly I'm surprised it worked as far as it did.

Instead you have a few options:

1. Create one proxy as you do, then extract the JsonRpc object from behind that proxy using the IJsonRpcProxy interface (or whatever it's called) and then call the instance Attach method on that to create your second proxy.
2. Create your JsonRpc object first then call the instance Attach on that twice.
3. Ask for one proxy that implements both interfaces at once.

[Dylan Vos (ThaDaVos)]

I tried 1 and 2 bot then I got This operation is not allowed before listening for messages has started. or the one about not allowed to modify it - so I thought that was the wrong way, hence why I followed the docs and used the Static version.

How does one do 3? By creating an interface implementing both and using that?

Maybe the docs need to be extended to show this usecase?

[Andrew Arnott (AArnott)]

Sorry for the delay in response.
I am taking your suggestion to enhance the docs. You can see the change early before the PR merges to get an answer to your question.
#1470

[SRI VILLIAM SAI A (srivilliamsai)]

The issue happens because calling the static JsonRpc.Attach<T>(stream) twice creates two separate JsonRpc instances competing over the same stream.

The correct way to use multiple proxies over a single stream is to create one JsonRpc instance first, attach your interfaces, and then call StartListening():

var namedPipeClientStream = NamedPipeFactory.CreateNamedPipeClient(autoConnect: true);

// 1. Create a single JsonRpc connection
var jsonRpc = new JsonRpc(namedPipeClientStream);

// 2. Attach multiple proxies to the same connection
var proxyA = jsonRpc.Attach<IInterfaceA>();
var proxyB = jsonRpc.Attach<IInterfaceB>();

// 3. Start listening on the connection
jsonRpc.StartListening();

// 4. Now both proxies work concurrently and thread-safely
await proxyA.SomeMethodA();
await proxyB.SomeMethodB();