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