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