Grpc - use rx observable - system.reactive

Question

I am trying to expose an observable via a GRPC stream.
my simplified code looks like this:
public override async Task Feed(Request request, IServerStreamWriter<Response> responseStream, ServerCallContext context)
{
var result = new Result();
try
{
await Observable.ForEachAsync(async value =>
{
await responseStream.WriteAsync(value);
});
}
catch (Exception ex)
{
Log.Info("Session ended:" + ex);
}
}
I receive the following error:
W0123 14:30:59.709715
Grpc.Core.Internal.ServerStreamingServerCallHandler2 Exception
occured in handler. System.ArgumentException: Der Wert liegt außerhalb
des erwarteten Bereichs. bei
Grpc.Core.Internal.ServerStreamingServerCallHandler2.d__4.MoveNext()
W0123 14:30:59.732716 Grpc.Core.Server Exception while handling RPC.
System.InvalidOperationException: Der Vorgang ist aufgrund des
aktuellen Zustands des Objekts ungültig. bei
Grpc.Core.Internal.AsyncCallServer2.SendStatusFromServerAsync(Status
status, Metadata trailers, Tuple2 optionalWrite) bei
Grpc.Core.Internal.ServerStreamingServerCallHandler`2.d__4.MoveNext()
--- Ende der Stapelüberwachung vom vorhergehenden Ort, an dem die Ausnahme ausgelöst wurde --- bei
System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task
task) bei
System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task
task) bei Grpc.Core.Server.d__34.MoveNext()
How would you recommend to handle this? I guess I would need to process the ForEachAsync in the same thread.

Answer 1

With the gRPC streaming API, you are only allowed to write one item at a time. If you start another WriteAsync() operation before the previous one finishes, you'll get an exception. You also need to finish all your writes before returning from the method handler (the Feed method in this case). The reason only one write is allowed at a time is to ensure gRPC's flow control works well.
In your case the Rx API doesn't seem to be capable of ensuring that, so one way to solve this would be to use an intermediate buffer.

Answer 2

How about this?
public override async Task Feed(Request request, IServerStreamWriter<Response> responseStream, ServerCallContext context)
{
var result = new Result();
try
{
await Observable.Scan(Task.CompletedTask, (preceding,value) =>
preceding.ContinueWith(_ => responseStream.WriteAsync(value))
);
}
catch (Exception ex)
{
Log.Info("Session ended:" + ex);
}
}
I haven't tested it yet, but I think it works anyway.

Answer 3

There are two issues preventing the OP's method from working as expected both stemming from the responseStream.WriteAsync's expectation that only one write can be pending at a time.
When the observable is subscribed to, each 'onNext' will be processed on the same thread that raised the notification. This means you be able to enforce the one write at a time rule. You can use the ObserveOn method to control how each notification will be scheduled.
var eventLoop = new EventLoopScheduler();
var o = myObservable.ObserveOn(eventLoop);
ForEachAsync doesn't work like it looks like one might think with async lambdas. If you drop the async/await here and instead call WriteAsync like this, then the Write will be executed in the expected context.
responseStream.WriteAsync<Response>(value).Wait();
Here is a complete example...
public override async Task Feed(Request request, IServerStreamWriter<Response> responseStream, ServerCallContext context)
{
var o = getMyObservable(request);
try
{
var eventLoop = new EventLoopScheduler(); //just for example, use whatever scheduler makes sense for you.
await o.ObserveOn(eventLoop).ForEachAsync<Response>(value =>
{
responseStream.WriteAsync(value).Wait();
},
context.CancellationToken);
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
Log.Info("Session ended:" + ex);
}
Log.Info("Session ended normally");
}