public async Task SendValidRequest_StreamedContentReturned() { // Arrage var httpClient = CreateGrpcWebClient(); var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions { HttpClient = httpClient, LoggerFactory = LoggerFactory }); var client = new EchoService.EchoServiceClient(channel); // Act var call = client.ServerStreamingEcho(new ServerStreamingEchoRequest { Message = "test", MessageCount = 3, MessageInterval = TimeSpan.FromMilliseconds(10).ToDuration() }); // Assert Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout()); Assert.AreEqual("test", call.ResponseStream.Current.Message); Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout()); Assert.AreEqual("test", call.ResponseStream.Current.Message); Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout()); Assert.AreEqual("test", call.ResponseStream.Current.Message); Assert.IsFalse(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout()); Assert.AreEqual(null, call.ResponseStream.Current); Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode); }
public async Task SendValidRequest_WithConnectionOptions(TestServerEndpointName endpointName, string?version, bool success) { SetExpectedErrorsFilter(writeContext => { return(!success); }); // Arrage Version.TryParse(version, out var v); var channel = CreateGrpcWebChannel(endpointName, v); var client = new EchoService.EchoServiceClient(channel); // Act var call = client.EchoAsync(new EchoRequest { Message = "test" }).ResponseAsync.DefaultTimeout(); // Assert if (success) { Assert.AreEqual("test", (await call).Message); } else { await ExceptionAssert.ThrowsAsync <RpcException>(async() => await call); } }
/// <summary> /// This example uses the Grpc operations on the stats service client. The Grpc methods allow specifying /// Grpc Headers and are tightly coupled with the Grpc interfaces. /// </summary> private static async Task GrpcOperations(EchoService.EchoServiceClient client) { // Unary operation { SingleMessage unaryResponse = await client.EchoUnary(new SingleMessage { Message = "hi there" }, default); Console.WriteLine($"EchoUnary: {unaryResponse.Message}"); } // Client streaming { AsyncClientStreamingCall <SingleMessage, MultiMessage> call = client.EchoClientStreaming(default);
private void Test() { var channel = new Channel("127.0.0.1:6565", ChannelCredentials.Insecure); var client = new EchoService.EchoServiceClient(channel); var reply = client.EchoService(new EchoMessage { Message = "test" }); channel.ShutdownAsync().Wait(); }
private async Task GrpcWebUnaryAbortAsync(EchoService.EchoServiceClient client) { try { await client.EchoAbortAsync(new EchoRequest { Message = "test" }); Assert.Fail(); } catch (RpcException ex) { Assert.AreEqual(StatusCode.Aborted, ex.StatusCode); } }
public async Task SendValidRequest_ServerAbort_ClientThrowsAbortException() { // Arrage SetExpectedErrorsFilter(r => { if (r.EventId.Name == "RpcConnectionError" && r.Message == "Error status code 'Aborted' raised.") { return(true); } if (r.EventId.Name == "GrpcStatusError" && r.Message == "Call failed with gRPC error status. Status code: 'Aborted', Message: 'Aborted from server side.'.") { return(true); } return(false); }); var httpClient = CreateGrpcWebClient(); var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions { HttpClient = httpClient, LoggerFactory = LoggerFactory }); var client = new EchoService.EchoServiceClient(channel); // Act var call = client.ServerStreamingEchoAbort(new ServerStreamingEchoRequest { Message = "test", MessageCount = 3, MessageInterval = TimeSpan.FromMilliseconds(10).ToDuration() }); // Assert Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout()); Assert.AreEqual("test", call.ResponseStream.Current.Message); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseStream.MoveNext(CancellationToken.None)); Assert.AreEqual(StatusCode.Aborted, ex.StatusCode); Assert.AreEqual("Aborted from server side.", ex.Status.Detail); Assert.AreEqual(StatusCode.Aborted, call.GetStatus().StatusCode); }
static async Task Main(string[] args) { using var channel = GrpcChannel.ForAddress("https://localhost:5001"); var client = new EchoService.EchoServiceClient(channel); // Create chat rpc stream using var echoStream = client.Echo(); // Wire up CallbackHandler to ResponseStream - print echo from service var callbackHandler = new CallbackHandler(echoStream.ResponseStream); // Run input loop await InputLoop(echoStream); // Run callback loop await callbackHandler.Task; }
public void Echo() { Debug.Log("echo start"); var channel = new Channel("127.0.0.1" + kPortNum, ChannelCredentials.Insecure); var client = new EchoService.EchoServiceClient(channel); var reply = client.EchoService(new EchoMessage { Message = echoField_.text }); Debug.Log("<color=red>" + reply.Message + "</color>"); channel.ShutdownAsync().Wait(); Debug.Log("echo End"); }
static async Task Main(string[] args) { // The port number(5001) must match the port of the gRPC server. using var channel = GrpcChannel.ForAddress("https://localhost:5001"); var weatherclient = new WeatherService.WeatherServiceClient(channel); var currentData = await weatherclient.RequestCurrentWeatherDataAsync(new WeatherRequest { Location = "MyTown" }); var historicData = await weatherclient.RequestHistoricDataAsync(new WeatherRequest { Location = "MyTown" }); var client = new Greeter.GreeterClient(channel); var reply = await client.SayHelloAsync(new HelloRequest { Name = "GreeterClient" }); Console.WriteLine( $"The current weather for {currentData.Location} is {currentData.Temperature} degrees F with winds {currentData.Windspeed} from {currentData.Winddirection}"); Console.WriteLine( $"The high temps for the past 10 days were "); foreach (var data in historicData.Data) { Console.WriteLine($"{data.Temperature}"); } var echoClient = new EchoService.EchoServiceClient(channel); var response = echoClient.EchoMe( new EchoRequest() { Text = $"ABCDEFG-{DateTime.Now.ToShortDateString()}" }); Console.WriteLine($"[{response.Original}] => [{response.Result}]"); response = echoClient.ReverseEcho( new EchoRequest() { Text = $"ABCDEFG-{DateTime.Now.ToShortDateString()}" }); Console.WriteLine($"[{response.Original}] => [{response.Result}]"); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); }
public async Task SendValidRequest_SuccessResponse() { // Arrage var httpClient = CreateGrpcWebClient(); var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions { HttpClient = httpClient, LoggerFactory = LoggerFactory }); var client = new EchoService.EchoServiceClient(channel); // Act var response = await client.EchoAsync(new EchoRequest { Message = "test" }).ResponseAsync.DefaultTimeout(); // Assert Assert.AreEqual("test", response.Message); }
private async Task GrpcWebServerStreamingAsync(EchoService.EchoServiceClient client) { var call = client.ServerStreamingEcho(new ServerStreamingEchoRequest { Message = "test", MessageCount = 5, MessageInterval = Google.Protobuf.WellKnownTypes.TimeExtensions.ToDuration(TimeSpan.FromMilliseconds(100)) }); var messages = new List <ServerStreamingEchoResponse>(); await foreach (var message in call.ResponseStream.ReadAllAsync()) { messages.Add(message); } Assert.AreEqual(5, messages.Count); }
private async Task EchoTest(Func <EchoService.EchoServiceClient, Task> callback) { Server server = new Server(); try { server.Services.Add(EchoService.BindService(new EchoServer())); server.Ports.Add(new ServerPort("127.0.0.1", 0, ServerCredentials.Insecure)); server.Start(); int port = server.Ports.Single().BoundPort; EchoService.EchoServiceClient client = new EchoService.EchoServiceClient(new Channel("127.0.0.1", port, ChannelCredentials.Insecure)); await callback(client); } finally { await server.KillAsync(); } }
private async Task GrpcWebServerStreamingAbortAsync(EchoService.EchoServiceClient client) { var call = client.ServerStreamingEchoAbort(new ServerStreamingEchoRequest { Message = "test", MessageCount = 5, MessageInterval = Google.Protobuf.WellKnownTypes.TimeExtensions.ToDuration(TimeSpan.FromMilliseconds(100)) }); try { await foreach (var message in call.ResponseStream.ReadAllAsync()) { } Assert.Fail(); } catch (RpcException ex) { Assert.AreEqual(StatusCode.Aborted, ex.StatusCode); } }
public async Task SendValidRequest_ClientAbort_ClientThrowsCancelledException() { // Arrage var httpClient = CreateGrpcWebClient(); var channel = GrpcChannel.ForAddress(httpClient.BaseAddress !, new GrpcChannelOptions { HttpClient = httpClient, LoggerFactory = LoggerFactory }); var cts = new CancellationTokenSource(); var client = new EchoService.EchoServiceClient(channel); // Act var call = client.ServerStreamingEcho(new ServerStreamingEchoRequest { Message = "test", MessageCount = 2, MessageInterval = TimeSpan.FromMilliseconds(100).ToDuration() }, cancellationToken: cts.Token); // Assert Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout()); Assert.AreEqual("test", call.ResponseStream.Current.Message); cts.Cancel(); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseStream.MoveNext(CancellationToken.None)).DefaultTimeout(); Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode); Assert.AreEqual("Call canceled by the client.", ex.Status.Detail); Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode); // It is possible get into a situation where the response stream finishes slightly before the call. // Small delay to ensure call logging is complete. await Task.Delay(50); AssertHasLog(LogLevel.Information, "GrpcStatusError", "Call failed with gRPC error status. Status code: 'Cancelled', Message: 'Call canceled by the client.'."); }
public async Task SendValidRequest_WithConnectionOptions(TestServerEndpointName endpointName, string?version, bool success) { #if NET6_0_OR_GREATER if (endpointName == TestServerEndpointName.Http3WithTls && !RequireHttp3Attribute.IsSupported(out var message)) { Assert.Ignore(message); } #endif SetExpectedErrorsFilter(writeContext => { return(!success); }); // Arrage Version.TryParse(version, out var v); var channel = CreateGrpcWebChannel(endpointName, v); var client = new EchoService.EchoServiceClient(channel); // Act var call = client.EchoAsync(new EchoRequest { Message = "test" }).ResponseAsync.DefaultTimeout(); // Assert if (success) { Assert.AreEqual("test", (await call.DefaultTimeout()).Message); } else { await ExceptionAssert.ThrowsAsync <RpcException>(async() => await call).DefaultTimeout(); } }
private async Task GrpcWebUnaryAsync(EchoService.EchoServiceClient client) { var response = await client.EchoAsync(new EchoRequest { Message = "test" }); Assert.AreEqual("test", response.Message); }