public async Task ServerStreamingCall_CancelClientSideRead() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { await responseStream.WriteAsync("abc"); while (!context.CancellationToken.IsCancellationRequested) { await Task.Delay(10); } }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), ""); await call.ResponseStream.MoveNext(); Assert.AreEqual("abc", call.ResponseStream.Current); var cts = new CancellationTokenSource(); var moveNextTask = call.ResponseStream.MoveNext(cts.Token); cts.Cancel(); try { // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock. await moveNextTask; Assert.Fail(); } catch (RpcException ex) { Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode); } }
/// <summary> /// Invokes a server streaming call asynchronously. /// In server streaming scenario, client sends on request and server responds with a stream of responses. /// </summary> public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { var call = CreateCall(method, host, options); var response = Calls.AsyncServerStreamingCall(call, request); return(response); }
public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method , string host , CallOptions options , TRequest request) { return(Calls.AsyncServerStreamingCall(CreateCall(method, host, options), request)); }
public async Task ServerStreamingCall_EndOfStreamIsIdempotent() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>((request, responseStream, context) => TaskUtils.CompletedTask); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), ""); Assert.IsFalse(await call.ResponseStream.MoveNext()); Assert.IsFalse(await call.ResponseStream.MoveNext()); }
public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { var _context = new ClientInterceptorContext <TRequest, TResponse>(method, host, options); _tracer.Request(request, _context); var rspCnt = Calls.AsyncServerStreamingCall(CreateCall(method, host, options), request); var tracingResponseStream = new TracingAsyncClientStreamReader <TResponse, TRequest>(rspCnt.ResponseStream, _context, _tracer.Response, _tracer.Finish, _tracer.Exception); return(new AsyncServerStreamingCall <TResponse>(tracingResponseStream, rspCnt.ResponseHeadersAsync, rspCnt.GetStatus, rspCnt.GetTrailers, rspCnt.Dispose)); }
/// <summary> /// Invokes a server streaming call asynchronously. /// In server streaming scenario, client sends on request and server responds with a stream of responses. /// </summary> public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>( Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { CallOptions updateOptions = ProcessOptions(options); var call = CreateCall(method, host, updateOptions); return(Calls.AsyncServerStreamingCall(call, request)); }
public void ResponseParsingError_StreamingResponse() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { await responseStream.WriteAsync("UNPARSEABLE_VALUE"); await Task.Delay(10000); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), "REQUEST"); var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseStream.MoveNext()); Assert.AreEqual(StatusCode.Internal, ex.Status.StatusCode); }
public async Task ResponseHeadersAsync_ServerStreamingCall() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { await context.WriteResponseHeadersAsync(headers); await responseStream.WriteAsync("PASS"); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), ""); var responseHeaders = await call.ResponseHeadersAsync; Assert.AreEqual("ascii-header", responseHeaders[0].Key); CollectionAssert.AreEqual(new[] { "PASS" }, await call.ResponseStream.ToListAsync()); }
public async Task ServerStreamingCall() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { await responseStream.WriteAllAsync(request.Split(new [] { ' ' })); context.ResponseTrailers.Add("xyz", ""); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), "A B C"); CollectionAssert.AreEqual(new string[] { "A", "B", "C" }, await call.ResponseStream.ToListAsync()); Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode); Assert.AreEqual("xyz", call.GetTrailers()[0].Key); }
public async Task ServerStreamingCall_ErrorCanBeAwaitedTwice() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { context.Status = new Status(StatusCode.InvalidArgument, ""); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), ""); var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseStream.MoveNext()); Assert.AreEqual(StatusCode.InvalidArgument, ex.Status.StatusCode); // attempting MoveNext again should result in throwing the same exception. var ex2 = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseStream.MoveNext()); Assert.AreEqual(StatusCode.InvalidArgument, ex2.Status.StatusCode); }
/// <summary> /// Invokes a server streaming call asynchronously. /// In server streaming scenario, client sends on request and server responds with a stream of responses. /// </summary> public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { using (var clientTrace = new ClientTrace(_serviceName, "grpc")) { var trace = clientTrace.Trace; var channel = new Channel(_target, ChannelCredentials.Insecure); var call = CreateCall(channel, method, host, options, trace); try { var response = Calls.AsyncServerStreamingCall(call, request); return(response); } finally { channel.ShutdownAsync(); } } }
public async Task ServiceConfigRetryPolicy_ServerStreaming() { var counter = new AtomicCounter(); helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { var attempt = counter.Increment(); if (attempt <= 2) { throw new RpcException(new Status(StatusCode.Unavailable, $"Attempt {attempt} failed on purpose")); } await responseStream.WriteAllAsync(request.Split(new [] { ' ' })); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), "A B C"); CollectionAssert.AreEqual(new string[] { "A", "B", "C" }, await call.ResponseStream.ToListAsync()); Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode); }
public async Task WriteResponseHeaders_NotAllowedAfterWrite() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { await responseStream.WriteAsync("A"); try { await context.WriteResponseHeadersAsync(headers); Assert.Fail(); } catch (InvalidOperationException expected) { } await responseStream.WriteAsync("B"); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), ""); var responses = await call.ResponseStream.ToListAsync(); CollectionAssert.AreEqual(new[] { "A", "B" }, responses); }
public void ServerStreamingCall_TrailersFromMultipleSourcesGetConcatenated() { helper.ServerStreamingHandler = new ServerStreamingServerMethod <string, string>((request, responseStream, context) => { context.ResponseTrailers.Add("xyz", "xyz-value"); throw new RpcException(new Status(StatusCode.InvalidArgument, ""), new Metadata { { "abc", "abc-value" } }); }); var call = Calls.AsyncServerStreamingCall(helper.CreateServerStreamingCall(), ""); var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseStream.MoveNext()); Assert.AreEqual(StatusCode.InvalidArgument, ex.Status.StatusCode); Assert.AreEqual(2, call.GetTrailers().Count); Assert.AreEqual(2, ex.Trailers.Count); Assert.AreEqual("xyz", ex.Trailers[0].Key); Assert.AreEqual("xyz-value", ex.Trailers[0].Value); Assert.AreEqual("abc", ex.Trailers[1].Key); Assert.AreEqual("abc-value", ex.Trailers[1].Value); }
/// <summary> /// Invokes a server streaming call asynchronously. /// In server streaming scenario, client sends on request and server responds with a stream of responses. /// </summary> public override AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { var trace = this.ResolveTraceSpan().Child(); trace.Record(Annotations.ClientSend()); trace.Record(Annotations.ServiceName(_serviceName)); trace.Record(Annotations.Rpc("grpc")); var channel = new Channel(_target, ChannelCredentials.Insecure); var call = CreateCall(channel, method, host, options, trace); try { var response = Calls.AsyncServerStreamingCall(call, request); return(response); } finally { trace.Record(Annotations.ClientRecv()); channel.ShutdownAsync(); } }
AsyncServerStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options, TRequest request) { affinityByMethod.TryGetValue(method.FullName, out AffinityConfig affinityConfig); ChannelRef channelRef = PreProcess(affinityConfig, request); var callDetails = new CallInvocationDetails <TRequest, TResponse>(channelRef.Channel, method, host, options); var originalCall = Calls.AsyncServerStreamingCall(callDetails, request); // Executes affinity postprocess once the streaming response finishes its final batch. var gcpResponseStream = new GcpClientResponseStream <TRequest, TResponse>( originalCall.ResponseStream, (resp) => PostProcess(affinityConfig, channelRef, request, resp)); // Create a wrapper of the original AsyncServerStreamingCall. return(new AsyncServerStreamingCall <TResponse>( gcpResponseStream, originalCall.ResponseHeadersAsync, () => originalCall.GetStatus(), () => originalCall.GetTrailers(), () => originalCall.Dispose())); }
public AsyncServerStreamingCall <global::Math.Num> Fib(global::Math.FibArgs request, CallOptions options) { var call = CreateCall(__Method_Fib, options); return(Calls.AsyncServerStreamingCall(call, request)); }
public void Fib(FibArgs request, IObserver <Num> responseObserver, CancellationToken token = default(CancellationToken)) { var call = CreateCall(ServiceName, FibMethod); Calls.AsyncServerStreamingCall(call, request, responseObserver, token); }
public AsyncServerStreamingCall <global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, CallOptions options) { var call = CreateCall(__Method_ListFeatures, options); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <global::Grpc.Testing.StreamingOutputCallResponse> StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { var call = CreateCall(__Method_StreamingOutputCall, new CallOptions(headers, deadline, cancellationToken)); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <global::Grpc.Testing.StreamingOutputCallResponse> StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, CallOptions options) { var call = CreateCall(__Method_StreamingOutputCall, options); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <StreamingOutputCallResponse> StreamingOutputCall(StreamingOutputCallRequest request, CancellationToken token = default(CancellationToken)) { var call = CreateCall(ServiceName, StreamingOutputCallMethod); return(Calls.AsyncServerStreamingCall(call, request, token)); }
public AsyncServerStreamingCall <global::Playground.Common.ServiceDefinition.Person> ListenForNewPeople(global::Playground.Common.ServiceDefinition.ListenForNewPeopleRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { var call = CreateCall(__Method_ListenForNewPeople, new CallOptions(headers, deadline, cancellationToken)); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { var call = CreateCall(__Method_ListFeatures, new CallOptions(headers, deadline, cancellationToken)); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <global::Playground.Common.ServiceDefinition.Person> GetPersonList(global::Playground.Common.ServiceDefinition.PersonListRequest request, CallOptions options) { var call = CreateCall(__Method_GetPersonList, options); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <global::grpc.testing.StreamingOutputCallResponse> StreamingOutputCall(global::grpc.testing.StreamingOutputCallRequest request, CancellationToken token = default(CancellationToken)) { var call = CreateCall(__ServiceName, __Method_StreamingOutputCall); return(Calls.AsyncServerStreamingCall(call, request, token)); }
public AsyncServerStreamingCall <global::Playground.Common.ServiceDefinition.Person> ListenForNewPeople(global::Playground.Common.ServiceDefinition.ListenForNewPeopleRequest request, CallOptions options) { var call = CreateCall(__Method_ListenForNewPeople, options); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <global::Fibos.TheNumberS> FiboN(global::Fibos.NumberN request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { var call = CreateCall(__Method_FiboN, new CallOptions(headers, deadline, cancellationToken)); return(Calls.AsyncServerStreamingCall(call, request)); }
public AsyncServerStreamingCall <Num> Fib(FibArgs request, CancellationToken token = default(CancellationToken)) { var call = CreateCall(__ServiceName, __Method_Fib); return(Calls.AsyncServerStreamingCall(call, request, token)); }
public AsyncServerStreamingCall <global::Fibos.TheNumberS> FiboN(global::Fibos.NumberN request, CallOptions options) { var call = CreateCall(__Method_FiboN, options); return(Calls.AsyncServerStreamingCall(call, request)); }