public async Task <IActionResult> Create(EchoRequest request) { _logger.LogDebug("received request in controller"); var data = await _developerService.Echo(request); return(ApiResponseWithData(data)); }
public override Task <EchoReply> Echo(EchoRequest request, ServerCallContext context) { return(Task.FromResult(new EchoReply { Message = "Hello " + request.Name, })); }
public EchoResponse GenerateEcho(EchoRequest request) { return(new EchoResponse { Message = string.Format("Echo: {0}", request.Message) }); }
public Task <EchoResponse> Echo(EchoRequest request) { return(Task.FromResult(new EchoResponse { Message = $"{request.Message} from {Id}" })); }
public Task <EchoResponse> EchoAsync(EchoRequest message) { return(FromResult(new EchoResponse { Message = message.Message })); }
private void ValidateRequest(EchoRequest echoRequest) { if (echoRequest.Size < 0) { throw new System.ArgumentException($"{nameof(EchoRequest.Size)} should be greater or equal than zero"); } }
public void AppLauncherStartAppWhenRequired() { EchoRequest receivedRequest = null; Task <EchoRequest> HandleAsync(EchoRequest request, MethodCallContext context) { receivedRequest = request; return(Task.FromResult(request)); } RunWith10SecTimeout(async() => { using (await StartTestBrokerAsync()) { var serverOptionsBuilder = new ClientOptionsBuilder() .WithDefaultConfiguration("TestBroker") .WithProvidedService( "plexus.interop.testing.EchoService", x => x.WithUnaryMethod <EchoRequest, EchoRequest>("Unary", HandleAsync)) .WithApplicationId("plexus.interop.testing.EchoServer"); var appLauncher = RegisterDisposable(new TestAppLauncher(new [] { serverOptionsBuilder })); await appLauncher.StartAsync(); var client = ConnectEchoClient(); var request = CreateTestRequest(); var response = await client.Call(EchoUnaryMethod, request); response.ShouldBe(request); receivedRequest.ShouldBe(request); } }); }
public void UnaryCall() { RunWith10SecTimeout(async() => { Console.WriteLine("Starting test"); EchoRequest receivedRequest = null; MethodCallContext receivedCallContext = null; Task <EchoRequest> HandleAsync(EchoRequest request, MethodCallContext context) { receivedRequest = request; receivedCallContext = context; return(Task.FromResult(request)); } var client = ConnectEchoClient(); ConnectEchoServer(x => x .WithProvidedService( "plexus.interop.testing.EchoService", s => s.WithUnaryMethod <EchoRequest, EchoRequest>("Unary", HandleAsync) ) ); var sentRequest = CreateTestRequest(); Console.WriteLine("Starting call"); var response = await client.CallInvoker.Call(EchoUnaryMethod, sentRequest); Console.WriteLine("Response received"); receivedRequest.ShouldBe(sentRequest); response.ShouldBe(sentRequest); receivedCallContext.ShouldNotBeNull(); receivedCallContext.ConsumerApplicationId.ShouldBe("plexus.interop.testing.EchoClient"); receivedCallContext.ConsumerConnectionId.ShouldBe(client.ConnectionId); }); }
public override Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context) { Log($"Echo: {request.Message}"); return(Task.FromResult(new EchoResponse { Message = Logger.Id + request.Message })); }
private async Task WorkerAsync(CancellationToken cancellationToken) { var counter = 0; using (var response = _myStackServerClient.ServerStream(new ServerStreamRequest { Message = "Please start stream" })) { using (var responseStream = response.ResponseStream) { while (!cancellationToken.IsCancellationRequested) { var request = new EchoRequest { Message = $"msg #{++counter}" }; var rr = await _myStackServerClient.EchoAsync(request); await Console.Out.WriteLineAsync($"Echo({request.Message}) => {rr.Message}"); try { await _myStackServerClient.FailAsync(new FailRequest { Message = "AHHHH" }); } catch (RpcException ex) { await Console.Out.WriteLineAsync(ex.ToString()); } await Task.Delay(3000, cancellationToken); } } } }
public override Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context) { _logger.LogInformation("=> Echo({})", request.Message); return(Task.FromResult(new EchoResponse { Message = request.Message })); }
public Task EchoAsync() { var request = new EchoRequest(); validator.ValidateRequest(request, configuration).EnsureSuccess(); return(messenger.SendRequestAsync(request)); }
public async Task SendValidRequest_SuccessResponse() { // Arrange var requestMessage = new EchoRequest { Message = "test" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); // Act var grpcWebClient = CreateGrpcWebClient(); var response = await grpcWebClient.PostAsync( "grpc.gateway.testing.EchoService/Echo", new GrpcStreamContent(ms)).DefaultTimeout(); // Assert response.AssertIsSuccessfulGrpcRequest(); var s = await response.Content.ReadAsStreamAsync().DefaultTimeout(); var reader = PipeReader.Create(s); var message = await MessageHelpers.AssertReadStreamMessageAsync <EchoResponse>(reader).DefaultTimeout(); Assert.AreEqual("test", message !.Message); response.AssertTrailerStatus(); }
public async Task SendValidRequest_ServerAbort_AbortResponse() { // Arrange var requestMessage = new EchoRequest { Message = "test" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); // Act var grpcWebClient = CreateGrpcWebClient(); var response = await grpcWebClient.PostAsync( "grpc.gateway.testing.EchoService/EchoAbort", new GrpcStreamContent(ms)).DefaultTimeout(); // Assert response.AssertIsSuccessfulGrpcRequest(); var s = await response.Content.ReadAsStreamAsync().DefaultTimeout(); var reader = PipeReader.Create(s); var readResult = await reader.ReadAsync().AsTask().DefaultTimeout(); Assert.AreEqual(0, readResult.Buffer.Length); Assert.IsTrue(readResult.IsCompleted); Assert.AreEqual("10", response.Headers.GetValues("grpc-status").Single()); Assert.AreEqual("Aborted from server side.", response.Headers.GetValues("grpc-message").Single()); AssertHasLogRpcConnectionError(StatusCode.Aborted, "Aborted from server side."); }
public void RpcTest() { TcpRpcServer server = new TcpRpcServer(new EchoServer()); server.Start(); CertificateStorage storage = new CertificateStorage(); TcpRpcClient client = new TcpRpcClient(); client.Connect(new IPEndPoint(IPAddress.Loopback, 4242)); Assert.IsTrue(client.Connected); var request = new EchoRequest(Guid.NewGuid(), "hello"); var responseData = client.Execute(request.ToBinary()); var response = Serializable.FromBinary<EchoResponse>(responseData); Assert.AreEqual(request.RequestId, response.RequestId); Assert.AreEqual("hello", response.Message); client.Disconnect(); Assert.IsFalse(client.Connected); server.Stop(); }
public override Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context) { return(Task.FromResult(new EchoResponse { Message = request.Message })); }
public override Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context) { EchoResponse response = new EchoResponse { Name = request.Name, Message = request.Message }; return(Task.FromResult(response)); }
public override async Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context) { await Console.Out.WriteLineAsync($"Server received Echo({request.Message})"); return(new EchoResponse { Message = request.Message }); }
public override Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context) { _logger.LogInformation("client called start."); return(Task.FromResult(new EchoResponse { Text = "Hello " + request.Text + ", I'm from .net 5" })); }
static void Main(string[] args) { //change the headnode name here const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 12; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); //session in the session pool should be a shared session info.ShareSession = true; info.UseSessionPool = true; Console.Write("Creating a session using session pool for EchoService..."); using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); //to make sure the client id is unique among the sessions string clientId = Guid.NewGuid().ToString(); using (BrokerClient <IService1> client = new BrokerClient <IService1>(clientId, session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { EchoRequest request = new EchoRequest("hello world!"); client.SendRequest <EchoRequest>(request, i); } client.EndRequests(); Console.WriteLine("done"); Console.WriteLine("Retrieving responses..."); foreach (var response in client.GetResponses <EchoResponse>()) { try { string reply = response.Result.EchoResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message); } } Console.WriteLine("Done retrieving {0} responses", numRequests); } //should not purge the session if the session is expected to stay in the session pool //the shared session is kept in the session pool session.Close(false); } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
private static void Worker(int sessionId) { DurableSession session = DurableSession.AttachSession(new SessionAttachInfo(headnode, sessionId)); int numRequests = 32; NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); string guid = Guid.NewGuid().ToString(); // Create a BrokerClient proxy // This proxy is able to map One-Way, Duplex message exchange patterns // with the Request / Reply Services. As such, the client program can send the // requests, exit and re-attach to the session to retrieve responses (see the // FireNRecollect project for details using (BrokerClient <IService1> client = new BrokerClient <IService1>(guid, session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { // EchoRequest are created as you add Service Reference // EchoService to the project EchoRequest request = new EchoRequest("hello world!"); client.SendRequest <EchoRequest>(request, i); } // Flush the message. After this call, the runtime system // starts processing the request messages. If this call is not called, // the system will not process the requests. The client.GetResponses() will return // with an empty collection client.EndRequests(); client.Close(); Console.WriteLine("done"); } using (BrokerClient <IService1> client = new BrokerClient <IService1>(guid, session, binding)) { Console.WriteLine("Retrieving responses..."); // GetResponses from the runtime system // EchoResponse class is created as you add Service Reference "EchoService" // to the project foreach (var response in client.GetResponses <EchoResponse>()) { try { string reply = response.Result.EchoResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData <int>(), reply); } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData <int>(), ex.Message); } } Console.WriteLine("Done retrieving {0} responses", numRequests); } }
public async Task TestEcho() { var request = new EchoRequest { Message = "Hello World" }; var response = await Client.EchoAsync(request); Assert.AreEqual(request.Message, response.Message); }
public ActionResult <int> Echo([FromQuery] EchoRequest request) { if (request == null) { return(base.BadRequest()); } return(request.Number); }
public async Task <EchoResponse> RequestEchoAsync(string message) { PhotonClient client = GetClient("Test"); EchoRequest request = new EchoRequest(message); var response = await client.RequestAsync(request.OperationCode, request.Parameters); return(OperationFactory.GetResponse(response.OperationCode, response.Parameters, response.ReturnCode, response.DebugMessage) as EchoResponse); }
public override IActionResult Echo(EchoRequest echoRequest) { PingResponse response = new PingResponse() { Message = echoRequest.Message }; return(StatusCode(200, response)); }
public ValueTask <EchoResponse> EchoMessage(EchoRequest request) { var response = new EchoResponse() { Message = $"Echo {request.Message}" }; return(new ValueTask <EchoResponse>(response)); }
public override Task <EchoResponse> EchoMessage(EchoRequest request, ServerCallContext context) { var responseMessage = $"Echo: {request.Name}"; var echoResponse = new EchoResponse { Name = responseMessage }; return(Task.FromResult <EchoResponse>(echoResponse)); }
public override Task <EchoResponse> ReverseEcho(EchoRequest request, ServerCallContext context) { var response = new EchoResponse() { Original = request.Text, Result = request.Text.Reverse() }; return(Task.FromResult(response)); }
public async Task EchoAsync_ShouldReturnSameMessage() { var client = CreateClient(); var echoRequest = new EchoRequest { Message = "Hello World!" }; var outMessage = await client.EchoAsync(echoRequest); outMessage.Message.Should().Be(echoRequest.Message); }
private static async Task <ClientResponse> CreateGetRequest(string method, EchoRequest request) { var url = $"{Constants.GatewayUrl}/" + $"{method}/" + $"{HttpUtility.UrlEncode(request.MerchantId)}/" + $"{request.DateTime}/" + $"{HttpUtility.UrlEncode(request.Signature, Encoding.UTF8)}"; return(await GetRequestResponse(url)); }
public IActionResult Echo(string message) { EchoRequest request = new EchoRequest() { Message = message }; logger.LogInformation($"Echo: '{message}' processed"); return(Echo(request)); }
static void Main( string[] args ) { var container = CreateUnityContainer(); var message = new EchoRequest { Input = "Echo This" }; var mediator = (IMediator)container.Resolve( typeof( IMediator ) ); var result = mediator.Send( message ); Console.WriteLine( result ); return; }
public EchoResponse Execute(EchoRequest request) { return new EchoResponse{Result = request.Value}; }
/// <summary> Perform a call to bwsService.echo(). </summary> /// <returns>Returns true if echo is successful, and false otherwise.</returns> private static bool echo() { const string METHOD_NAME = "echo()"; const string BWS_API_NAME = "bwsService.echo()"; logMessage("Entering {0}", METHOD_NAME); bool returnValue = true; EchoRequest request = new EchoRequest(); EchoResponse response = null; request.metadata = REQUEST_METADATA; request.text = "Hello World!"; try { logRequest(BWS_API_NAME); response = bwsService.echo(request); logResponse(BWS_API_NAME, response.returnStatus.code, response.metadata); } catch (WebException e) { if (e.Status == WebExceptionStatus.ProtocolError) { HttpWebResponse httpWebResponse = (HttpWebResponse)e.Response; if (httpWebResponse != null && httpWebResponse.StatusCode == HttpStatusCode.Unauthorized) { returnValue = false; logMessage("Failed to authenticate with the BWS web service"); logMessage("Exiting {0} with value \"{1}\"", METHOD_NAME, returnValue); return returnValue; } } // Log and re-throw exception. logMessage("Exiting {0} with exception \"{1}\"", METHOD_NAME, e.Message); throw e; } logMessage("Exiting {0} with value \"{1}\"", METHOD_NAME, returnValue); return returnValue; }
public override void Echo(Google.ProtocolBuffers.IRpcController controller, EchoRequest request, Action<EchoResponse> done) { throw new NotImplementedException(); }
public override void Echo(IRpcController controller, EchoRequest request, Action<EchoResponse> done) { ProtoOutputBuffer.Write(request.GetType(), request.ToString()); }
public override void Echo(IRpcController controller, EchoRequest request, Action<EchoResponse> done) { throw new NotImplementedException(); }
static void Main(string[] args) { //change the headnode name here const string headnode = "localhost"; const string serviceName = "JavaEchoSvc1"; const int numRequests = 12; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); Console.Write("Creating a session for EchoService..."); // Create a durable session // Request and response messages in a durable session are persisted so that // in event of failure, no requests nor responses will be lost. Another authorized // client can attached to a session with the same session Id and retrieve responses using (DurableSession session = DurableSession.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); // Create a BrokerClient proxy // This proxy is able to map One-Way, Duplex message exchange patterns // with the Request / Reply Services. As such, the client program can send the // requests, exit and re-attach to the session to retrieve responses (see the // FireNRecollect project for details using (BrokerClient<IEchoSvc> client = new BrokerClient<IEchoSvc>(session, binding)) { Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { // EchoRequest are created as you add Service Reference // EchoService to the project EchoRequest request = new EchoRequest("hello world!"); client.SendRequest<EchoRequest>(request, i); } // Flush the message. After this call, the runtime system // starts processing the request messages. If this call is not called, // the system will not process the requests. The client.GetResponses() will return // with an empty collection client.EndRequests(); Console.WriteLine("done"); Console.WriteLine("Retrieving responses..."); // GetResponses from the runtime system // EchoResponse class is created as you add Service Reference "EchoService" // to the project foreach (var response in client.GetResponses<EchoResponse>()) { try { string reply = response.Result.EchoResult; Console.WriteLine("\tReceived response for request {0}: {1}", response.GetUserData<int>(), reply); } catch (Exception ex) { Console.WriteLine("Error occured while processing {0}-th request: {1}", response.GetUserData<int>(), ex.Message); } } Console.WriteLine("Done retrieving {0} responses", numRequests); } //explict close the session to free the resource session.Close(); } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public object Any(EchoRequest request) { ServerEvents.NotifyChannel("default-channel", "cmd.echo", request.ToEcho); return new EchoResponse { Echoed = request.ToEcho }; }