gRPC：如何在 stream gRPC 中找到特定的客户端

Question

I want to create Client and Server through gRPC Server Streaming. I would like to distinguish each client at this time. I looked into it, and I think we can choose using Uid to distinguish client or use peer to distinguish it.

What I am curious about is that when I want to send a response to only one specific client, I wonder if there is only a way to distinguish it through uid or peer after sending it to everyone. Can't the server send it to only one client from the beginning?

For example, suppose you created a server streaming grpc service called send(), request send() from multiple clients and wait for a response through stream. The server needs to respond to send() to a particular client, but I don't know how to generate only the send() service for this particular client.

Answer 1

One solution (but there might be better solutions) could be to pass a unique ID from the client to the server in the metadata, and have a centralized storage, like a singleton client manager class, for all connected clients on the server-side. This client manager class decides to who streams happen, and to who not.

For example, on the client-side the machine name is passed in the metadata when subscribing to the server stream as a identifier with the key client-id (though something like a GUID would probably more unique):

// client-side method that subscribes to the gRPC client
public async void Subscribe()
{
    // subscribe to the server stream with a unique client id
    _call = _serviceClient.SubscribeToServerStream(new Empty(), headers: new Metadata
    {
        new Metadata.Entry("client-id", Environment.MachineName)
    });

    // handle incoming messages from the server for this client
    await HandleIncomingServerMessages(_call.ResponseStream);
}

The server-side code is kinda simplified, but I think it explains the idea. The client-id gets extracted from the metadata, and added to the (singleton) _clientManager class, which holds all connected clients and manages to who streams should happen. Now if you want to stream to this connected client, the centralized client manager can set (just as an example) this client's streaming property to active, and you can check in the outgoing stream if this client is active or not (with the id you extracted from the call context), and therefore stream messages or not.

// server-side method in the gRPC service that implements the stream
public override async Task SubscribeToServerStream(Empty request,
    IServerStreamWriter<Message> responseStream,
    ServerCallContext context)
{
    // extract the unique client id
    _clientId = context.RequestHeaders.FirstOrDefault(m => String.Equals(m.Key, "client-id", StringComparison.Ordinal));

    // register it to the server-side client manager
    _clientManager.AddNewConnectedClient(_clientId);

    while(_isStreaming)
    {
        if(_clientManager.IsActiveClient(this._clientId))
        {
            // this client is set to active in the manager, therefore stream
        }
        else
        {
            // do nothing, since you currently do not want to stream to this connected client
        }
    }
}

I am pretty sure this will work, since I implemented something very similar not long ago, although it was kinda hacky (where multiple clients could connect, but only one of them could receive a stream at the same time, and there were some other conditions). But there might be better solutions to your problem than my answer, and I sadly do not have the time to write down and debug all the code to give you something that works out of the box.