public DispatchableRequest(IListenerReference <TRequest, TResponse> func, Envelope <TRequest> envelope, Guid listenerId, IResponseReceiver <TResponse> request)
{
_func = func;
_envelope = envelope;
_request = request;
ListenerId = listenerId;
}
public void Request(Envelope <TRequest> envelope, IResponseReceiver <TResponse> request)
{
var thread = _workerPool.GetThreadPoolDispatcher();
var responseWaiter = new DispatchableRequest <TRequest, TResponse>(_func, envelope, Id, request);
thread.DispatchAction(responseWaiter);
}
public void SetUp()
{
request = new SomeRequest();
response = new SomeResponse();
serverAddress = Mock.Of<IServerAddress>();
responseTypeFinder = Mock.Of<IResponseTypeFinder>();
responseReveiver = Mock.Of<IResponseReceiver>();
server = new Server(serverAddress, responseTypeFinder, responseReveiver);
Mock.Get(responseTypeFinder).Setup(f => f.FindResponseTypeOf(request.GetType())).Returns(typeof(SomeResponse));
Mock.Get(responseReveiver).Setup(r => r.ReceiveResponseAsync(It.IsAny<IServerAddress>(), It.IsAny<object>(), It.IsAny<Type>())).ReturnsAsync(response);
}
public void Request(Envelope <TRequest> envelope, IResponseReceiver <TResponse> request)
{
var thread = _workerPool.GetDispatcher(_threadId, false);
if (thread == null)
{
request.SetNoResponse();
return;
}
var responseWaiter = new DispatchableRequest <TRequest, TResponse>(_func, envelope, Id, request);
thread.DispatchAction(responseWaiter);
}
public void Request(Envelope <TRequest> envelope, IResponseReceiver <TResponse> request)
{
var thread = _workerPool.GetAnyWorkerDispatcher();
if (thread == null)
{
var response = _func.Invoke(envelope);
request.SetResponse(response);
return;
}
var responseWaiter = new DispatchableRequest <TRequest, TResponse>(_func, envelope, Id, request);
thread.DispatchAction(responseWaiter);
}
public async Task ReceiveResultTest()
{
var serializeMock = new Mock <BaseSerializer>();
serializeMock.Setup(serializer => serializer.Deserialize <int>(It.IsAny <ArraySegment <byte> >(), It.IsAny <Session>())).Returns(111);
serializeMock.Setup(serializer => serializer.Serialize(It.IsAny <A>(), It.IsAny <Session>())).Returns(new byte[10]);
var executor = new HostOperationExecutor <DefaultMessage, DefaultMessage>(OperationRuntimeModel.CreateFromAttribute(new[] { typeof(A) }), serializeMock.Object, new Mock <SessionCollection>().Object, new NullLoggerFactory());
var mockGenerator = new Mock <IGeneratorId>();
mockGenerator.Setup(id => id.Generate()).Returns(100);
executor.MessageIdGenerator = mockGenerator.Object;
IResponseReceiver <DefaultMessage> e = executor;
Task.Delay(100).ContinueWith(_ => e.Receive(new DefaultMessage()
{
OperationCode = 0, Status = BuiltInOperationState.Success, OperationData = new byte[10], Id = 100
}))
.GetAwaiter();
var result = await executor.Execute <A, int>(new A());
Assert.Equal(111, result.Result);
}
public void Request(Envelope <TRequest> envelope, IResponseReceiver <TResponse> request)
{
var value = _func.Invoke(envelope);
request.SetResponse(value);
}
public void Request(Envelope <int> envelope, IResponseReceiver <int> request)
{
request.SetError(new Exception("Should not get here"));
}
public Receiver(ICircuitBreaker circuitBreaker, IResponseReceiver <TResponse> inner)
{
_circuitBreaker = circuitBreaker;
_inner = inner;
}
public void Request <TRequest, TResponse>(string topic, Envelope <TRequest> envelope, IResponseReceiver <TResponse> request)
{
Assert.ArgumentNotNull(envelope, nameof(envelope));
Assert.ArgumentNotNull(request, nameof(request));
var topicEnvelope = envelope.RedirectToTopic(topic);
var listener = _store.GetListener <TRequest, TResponse>(topic);
if (listener == null)
{
_logger.Debug($"No listener configured for RequestType={typeof(TRequest).Name} ResponseType={typeof(TResponse).Name} Topic={topic}");
request.SetNoResponse();
return;
}
if (!listener.CanHandle(envelope))
{
request.SetNoResponse();
return;
}
_logger.Debug("Requesting RequestType={0} ResponseType={1} Topic={2} to listener Id={3}", typeof(TRequest).FullName, typeof(TResponse).FullName, envelope.Topics.FirstOrDefault(), listener.Id);
try
{
listener.Request(topicEnvelope, request);
}
catch (Exception e)
{
_logger.Error($"Error on request Type={typeof(TRequest).FullName}, {typeof(TResponse).FullName} Topic={topic}, Listener Id={listener.Id}: {e.Message}\n{e.StackTrace}");
request.SetError(e);
}
if (listener.ShouldStopListening)
{
_store.RemoveListener(topic, listener);
}
}
public void Subscribe(IResponseReceiver <TResponse> receiveEvent)
{
_responseReceiver = receiveEvent;
}
