public async Task ClientStreamingCall() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { string result = ""; await requestStream.ForEachAsync((request) => { result += request; return(TaskUtils.CompletedTask); }); await Task.Delay(100); return(result); }); { var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.WriteAllAsync(new string[] { "A", "B", "C" }); Assert.AreEqual("ABC", await call); Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode); Assert.IsNotNull(call.GetTrailers()); } { var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.WriteAllAsync(new string[] { "A", "B", "C" }); Assert.AreEqual("ABC", await call.ConfigureAwait(false)); Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode); Assert.IsNotNull(call.GetTrailers()); } }
public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { options = options.Headers == null?options.WithHeaders(new Metadata()) : options; var _context = new ClientInterceptorContext <TRequest, TResponse>(method, host, options); var rspCnt = Calls.AsyncClientStreamingCall(CreateCall(method, host, options)); var tracingRequestStream = new TracingClientStreamWriter <TRequest, TResponse>(rspCnt.RequestStream, _context, _tracer.Request); var rspAsync = rspCnt.ResponseAsync.ContinueWith(rspTask => { try { var response = rspTask.Result; _tracer.Response(response, _context); _tracer.Finish(_context); return(response); } catch (AggregateException ex) { _tracer.Exception(_context, ex.InnerException, null); throw ex.InnerException; } }); return(new AsyncClientStreamingCall <TRequest, TResponse>(tracingRequestStream, rspAsync, rspCnt.ResponseHeadersAsync, rspCnt.GetStatus, rspCnt.GetTrailers, rspCnt.Dispose)); }
public async Task ClientStreamingServerHandler_Auth_Failed() { var helper = new MockServiceBuilder(); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>((request, context) => Task.FromResult("ok")); helper.ServiceDefinition = helper.ServiceDefinition.Intercept(_authInterceptor); _server = helper.GetServer(); _server.Start(); _channel = helper.GetChannel(); await ShouldBeCancelRpcExceptionAsync(async() => await Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()).ResponseAsync); var method = new Method <string, string>(MethodType.ClientStreaming, MockServiceBuilder.ServiceName, "ClientStreaming", Marshallers.StringMarshaller, Marshallers.StringMarshaller); var peer = _peerPool.GetPeersByHost("127.0.0.1").First(); ((GrpcPeer)peer).InboundSessionId = new byte[] { 1, 2, 3 }; var callInvoker = helper.GetChannel().Intercept(metadata => { metadata = new Metadata { { GrpcConstants.PubkeyMetadataKey, peer.Info.Pubkey }, { GrpcConstants.SessionIdMetadataKey, new byte[] { 4, 5, 6 } } }; return(metadata); }); await ShouldBeCancelRpcExceptionAsync(async() => await callInvoker.AsyncClientStreamingCall(method, "localhost", new CallOptions()).ResponseAsync); }
/// <summary> /// Invokes a client streaming call asynchronously. /// In client streaming scenario, client sends a stream of requests and server responds with a single response. /// </summary> public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { var call = CreateCall(method, host, options); var response = Calls.AsyncClientStreamingCall(call); return(response); }
public async Task PropagateDeadline() { var deadline = DateTime.UtcNow.AddDays(7); helper.UnaryHandler = new UnaryServerMethod <string, string>((request, context) => { Assert.IsTrue(context.Deadline < deadline.AddMinutes(1)); Assert.IsTrue(context.Deadline > deadline.AddMinutes(-1)); return(Task.FromResult("PASS")); }); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { Assert.Throws(typeof(ArgumentException), () => { // Trying to override deadline while propagating deadline from parent call will throw. Calls.BlockingUnaryCall(helper.CreateUnaryCall( new CallOptions(deadline: DateTime.UtcNow.AddDays(8), propagationToken: context.CreatePropagationToken())), ""); }); var callOptions = new CallOptions(propagationToken: context.CreatePropagationToken()); return(await Calls.AsyncUnaryCall(helper.CreateUnaryCall(callOptions), "xyz")); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(deadline: deadline))); await call.RequestStream.CompleteAsync(); Assert.AreEqual("PASS", await call); }
AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { // No channel affinity feature for client streaming call. ChannelRef channelRef = GetChannelRef(); var callDetails = new CallInvocationDetails <TRequest, TResponse>(channelRef.Channel, method, host, options); var originalCall = Calls.AsyncClientStreamingCall(callDetails); // Decrease the active streams count once async response finishes. var gcpResponseAsync = DecrementCountAndPropagateResult(originalCall.ResponseAsync); // Create a wrapper of the original AsyncClientStreamingCall. return(new AsyncClientStreamingCall <TRequest, TResponse>( originalCall.RequestStream, gcpResponseAsync, originalCall.ResponseHeadersAsync, () => originalCall.GetStatus(), () => originalCall.GetTrailers(), () => originalCall.Dispose())); async Task <TResponse> DecrementCountAndPropagateResult(Task <TResponse> task) { try { return(await task.ConfigureAwait(false)); } finally { channelRef.ActiveStreamCountDecr(); } } }
public async Task ClientStreamingCall_ServerSideReadAfterCancelNotificationReturnsNull() { var handlerStartedBarrier = new TaskCompletionSource <object>(); var cancelNotificationReceivedBarrier = new TaskCompletionSource <object>(); var successTcs = new TaskCompletionSource <string>(); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { handlerStartedBarrier.SetResult(null); // wait for cancellation to be delivered. context.CancellationToken.Register(() => cancelNotificationReceivedBarrier.SetResult(null)); await cancelNotificationReceivedBarrier.Task; var moveNextResult = await requestStream.MoveNext(); successTcs.SetResult(!moveNextResult ? "SUCCESS" : "FAIL"); return(""); }); var cts = new CancellationTokenSource(); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token))); await handlerStartedBarrier.Task; cts.Cancel(); var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseAsync); Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode); Assert.AreEqual("SUCCESS", await successTcs.Task); }
public async Task ClientStreamingCall_CancelAfterBegin() { var barrier = new TaskCompletionSource <object>(); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { barrier.SetResult(null); await requestStream.ToListAsync(); return(""); }); var cts = new CancellationTokenSource(); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token))); await barrier.Task; // make sure the handler has started. cts.Cancel(); try { // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock. await call.ResponseAsync; Assert.Fail(); } catch (RpcException ex) { Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode); } }
/// <summary> /// Invokes a client streaming call asynchronously. /// In client streaming scenario, client sends a stream of requests and server responds with a single response. /// </summary> public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>( Method <TRequest, TResponse> method, string host, CallOptions options) { CallOptions updateOptions = ProcessOptions(options); var call = CreateCall(method, host, updateOptions); return(Calls.AsyncClientStreamingCall(call)); }
public void ClientStreamingCall() { Task.Run(async() => { var call = new Call <string, string>(ServiceName, ConcatAndEchoMethod, channel, Metadata.Empty); var callResult = Calls.AsyncClientStreamingCall(call, CancellationToken.None); await callResult.RequestStream.WriteAll(new string[] { "A", "B", "C" }); Assert.AreEqual("ABC", await callResult.Result); }).Wait(); }
public async Task RequestParsingError_StreamingRequest() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { Assert.Throws <IOException>(async() => await requestStream.MoveNext()); return("RESPONSE"); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.WriteAsync("UNPARSEABLE_VALUE"); Assert.AreEqual("RESPONSE", await call); }
public async Task PropagateCancellation() { var readyToCancelTcs = new TaskCompletionSource <object>(); var successTcs = new TaskCompletionSource <string>(); helper.UnaryHandler = new UnaryServerMethod <string, string>(async(request, context) => { readyToCancelTcs.SetResult(null); // child call running, ready to parent call while (!context.CancellationToken.IsCancellationRequested) { await Task.Delay(10); } successTcs.SetResult("CHILD_CALL_CANCELLED"); return(""); }); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { var propagationToken = context.CreatePropagationToken(); Assert.IsNotNull(propagationToken.AsImplOrNull().ParentCall); var callOptions = new CallOptions(propagationToken: propagationToken); try { await Calls.AsyncUnaryCall(helper.CreateUnaryCall(callOptions), "xyz"); } catch (RpcException) { // Child call will get cancelled, eat the exception. } return(""); }); var cts = new CancellationTokenSource(); var parentCall = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token))); await readyToCancelTcs.Task; cts.Cancel(); try { // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock. await parentCall; Assert.Fail(); } catch (RpcException) { } Assert.AreEqual("CHILD_CALL_CANCELLED", await successTcs.Task); }
public async Task ResponseHeadersAsync_ClientStreamingCall() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { await context.WriteResponseHeadersAsync(headers); return("PASS"); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.CompleteAsync(); var responseHeaders = await call.ResponseHeadersAsync; Assert.AreEqual("ascii-header", responseHeaders[0].Key); Assert.AreEqual("PASS", await call.ResponseAsync); }
public async Task RequestSerializationError_ClientStreaming() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { CollectionAssert.AreEqual(new[] { "A", "B" }, await requestStream.ToListAsync()); return("RESPONSE"); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.WriteAsync("A"); Assert.ThrowsAsync <IOException>(async() => await call.RequestStream.WriteAsync("UNSERIALIZABLE_VALUE")); await call.RequestStream.WriteAsync("B"); await call.RequestStream.CompleteAsync(); Assert.AreEqual("RESPONSE", await call); }
public async Task ClientStreamingCall() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { string result = ""; await requestStream.ForEachAsync(async(request) => { result += request; }); await Task.Delay(100); return(result); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.WriteAllAsync(new string[] { "A", "B", "C" }); Assert.AreEqual("ABC", await call.ResponseAsync); }
/// <summary> /// Invokes a client streaming call asynchronously. /// In client streaming scenario, client sends a stream of requests and server responds with a single response. /// </summary> public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { 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.AsyncClientStreamingCall(call); return(response); } finally { channel.ShutdownAsync(); } } }
public async Task HalfcloseAfterFullclose_ClientStreamingCall() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { return("PASS"); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); // make sure server has fullclosed on us Assert.AreEqual("PASS", await call.ResponseAsync); // sending close from client should be still fine because server can finish // the call anytime and we cannot do anything about it on the client side. await call.RequestStream.CompleteAsync(); // Second attempt to close from client is not allowed. Assert.ThrowsAsync(typeof(InvalidOperationException), async() => await call.RequestStream.CompleteAsync()); }
public async Task RequestParsingError_StreamingRequest() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { try { // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock. await requestStream.MoveNext(); Assert.Fail(); } catch (IOException) { } return("RESPONSE"); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); await call.RequestStream.WriteAsync("UNPARSEABLE_VALUE"); Assert.AreEqual("RESPONSE", await call); }
public async Task SuppressDeadlinePropagation() { helper.UnaryHandler = new UnaryServerMethod <string, string>((request, context) => { Assert.AreEqual(DateTime.MaxValue, context.Deadline); return(Task.FromResult("PASS")); }); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { Assert.IsTrue(context.CancellationToken.CanBeCanceled); var callOptions = new CallOptions(propagationToken: context.CreatePropagationToken(new ContextPropagationOptions(propagateDeadline: false))); return(await Calls.AsyncUnaryCall(helper.CreateUnaryCall(callOptions), "xyz")); }); var cts = new CancellationTokenSource(); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(deadline: DateTime.UtcNow.AddDays(7)))); await call.RequestStream.CompleteAsync(); Assert.AreEqual("PASS", await call); }
/// <summary> /// Invokes a client streaming call asynchronously. /// In client streaming scenario, client sends a stream of requests and server responds with a single response. /// </summary> public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { 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.AsyncClientStreamingCall(call); return(response); } finally { trace.Record(Annotations.ClientRecv()); channel.ShutdownAsync(); } }
public void ClientStreamingCall_CancelAfterBegin() { Task.Run(async() => { var call = new Call <string, string>(ServiceName, ConcatAndEchoMethod, channel, Metadata.Empty); var cts = new CancellationTokenSource(); var callResult = Calls.AsyncClientStreamingCall(call, cts.Token); // TODO(jtattermusch): we need this to ensure call has been initiated once we cancel it. await Task.Delay(1000); cts.Cancel(); try { await callResult.Result; } catch (RpcException e) { Assert.AreEqual(StatusCode.Cancelled, e.Status.StatusCode); } }).Wait(); }
public async Task ClientStreamingCall_CancelServerSideRead() { helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { var cts = new CancellationTokenSource(); var moveNextTask = requestStream.MoveNext(cts.Token); cts.Cancel(); await moveNextTask; return(""); }); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall()); try { // cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock. await call.ResponseAsync; Assert.Fail(); } catch (RpcException ex) { Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode); } }
public async Task PropagateCancellation() { helper.UnaryHandler = new UnaryServerMethod <string, string>(async(request, context) => { // check that we didn't obtain the default cancellation token. Assert.IsTrue(context.CancellationToken.CanBeCanceled); return("PASS"); }); helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { var propagationToken = context.CreatePropagationToken(); Assert.IsNotNull(propagationToken.ParentCall); var callOptions = new CallOptions(propagationToken: propagationToken); return(await Calls.AsyncUnaryCall(helper.CreateUnaryCall(callOptions), "xyz")); }); var cts = new CancellationTokenSource(); var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token))); await call.RequestStream.CompleteAsync(); Assert.AreEqual("PASS", await call); }
public AsyncClientStreamingCall <global::Playground.Common.ServiceDefinition.Person, global::Playground.Common.ServiceDefinition.PersonListResponse> CreatePeople(CallOptions options) { var call = CreateCall(__Method_CreatePeople, options); return(Calls.AsyncClientStreamingCall(call)); }
public AsyncClientStreamingCall <global::Playground.Common.ServiceDefinition.Person, global::Playground.Common.ServiceDefinition.PersonListResponse> CreatePeople(Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { var call = CreateCall(__Method_CreatePeople, new CallOptions(headers, deadline, cancellationToken)); return(Calls.AsyncClientStreamingCall(call)); }
public AsyncClientStreamingCall <global::grpc.testing.StreamingInputCallRequest, global::grpc.testing.StreamingInputCallResponse> StreamingInputCall(CancellationToken token = default(CancellationToken)) { var call = CreateCall(__ServiceName, __Method_StreamingInputCall); return(Calls.AsyncClientStreamingCall(call, token)); }
public AsyncClientStreamingCall <StreamingInputCallRequest, StreamingInputCallResponse> StreamingInputCall(CancellationToken token = default(CancellationToken)) { var call = CreateCall(ServiceName, StreamingInputCallMethod); return(Calls.AsyncClientStreamingCall(call, token)); }
public AsyncClientStreamingCall <Num, Num> Sum(CancellationToken token = default(CancellationToken)) { var call = CreateCall(__ServiceName, __Method_Sum); return(Calls.AsyncClientStreamingCall(call, token)); }
public override AsyncClientStreamingCall <TRequest, TResponse> AsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { return(Calls.AsyncClientStreamingCall(CreateCall(method, host, options))); }
/// <inheritdoc cref="CallInvoker.CreateAsyncClientStreamingCall{TRequest,TResponse}" /> public override AsyncClientStreamingCall <TRequest, TResponse> CreateAsyncClientStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { var call = CreateCallDetails(method, host, options); return(Calls.AsyncClientStreamingCall(call)); }