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));
}
