private async Task HandleStateOfTheWorldRequest()
{
using (_stateRequestSocket = new RouterSocket())
{
_stateRequestSocket.Bind(_configuration.StateOftheWorldEndpoint);
while (!_cancel.IsCancellationRequested)
{
var message = _stateRequestSocket.ReceiveMultipartMessage();
var sender = message[0].Buffer;
var request = _serializer.Deserialize <IStateRequest>(message[1].Buffer);
var stream = await _cache.GetStreamBySubject(request.Subject);
var response = new StateReply()
{
Subject = request.Subject,
Events = stream.ToList()
};
_stateRequestSocket.SendMoreFrame(sender)
.SendFrame(_serializer.Serialize(response));
}
}
}
private Task HandleStateOfTheWorldRequest()
{
using (var stateRequestSocket = new RouterSocket())
{
stateRequestSocket.Bind(_configuration.StateOfTheWorldEndpoint);
using (_stateRequestPoller = new NetMQPoller {
stateRequestSocket
})
{
stateRequestSocket.ReceiveReady += async(s, e) =>
{
try
{
NetMQMessage message = null;
while (e.Socket.TryReceiveMultipartMessage(ref message))
{
var sender = message[0].Buffer;
var request = _serializer.Deserialize <StateRequest>(message[1].Buffer);
var stream = await _cache.GetStreamBySubject(request.Subject);
var response = new StateReply()
{
Subject = request.Subject,
Events = stream.ToList()
};
e.Socket.SendMoreFrame(sender)
.SendFrame(_serializer.Serialize(response));
}
}
catch (Exception ex)
{
Errors.Add(new ActorMonitoringError()
{
CacheErrorStatus = ActorErrorType.DynamicCacheEventHandlingFailure,
Exception = ex
});
}
};
_stateRequestPoller.Run();
}
}
return(Task.CompletedTask);
}
private void SetupFakeBroker(
CancellationToken cancel,
IEventCache eventCache,
bool useHeartbeat = true,
bool useEventLoop = true,
bool useStateOfTheWorld = true)
{
if (useHeartbeat)
{
//heartbeat
Task.Run(() =>
{
using (var heartbeatSocket = new ResponseSocket(HeartbeatEndpoint))
{
while (!cancel.IsCancellationRequested)
{
var hasResponse = heartbeatSocket.TryReceiveFrameBytes(TimeSpan.FromSeconds(1), out var messageBytes);
if (hasResponse)
{
heartbeatSocket.SendFrame(_serializer.Serialize(Heartbeat.Response));
}
}
}
}, cancel);
}
if (useEventLoop)
{
//event loop
Task.Run(async() =>
{
using (var stateUpdate = new SubscriberSocket())
{
stateUpdate.SubscribeToAnyTopic();
stateUpdate.Bind(ToPublishersEndpoint);
while (!cancel.IsCancellationRequested)
{
NetMQMessage message = null;
var hasResponse = stateUpdate.TryReceiveMultipartMessage(TimeSpan.FromSeconds(1), ref message);
if (hasResponse)
{
var subject = message[0];
var payload = message[1];
await eventCache.AppendToStream(subject.Buffer, payload.Buffer);
}
}
}
}, cancel);
}
if (useStateOfTheWorld)
{
//stateOfTheWorld
Task.Run(async() =>
{
using (var stateRequestSocket = new RouterSocket())
{
stateRequestSocket.Bind(StateOfTheWorldEndpoint);
while (!cancel.IsCancellationRequested)
{
NetMQMessage message = null;
var hasResponse = stateRequestSocket.TryReceiveMultipartMessage(TimeSpan.FromSeconds(1), ref message);
if (hasResponse)
{
var sender = message[0].Buffer;
var request = _serializer.Deserialize <StateRequest>(message[1].Buffer);
var stream = await eventCache.GetStreamBySubject(request.Subject);
var response = new StateReply()
{
Subject = request.Subject,
Events = stream.ToList()
};
stateRequestSocket.SendMoreFrame(sender)
.SendFrame(_serializer.Serialize(response));
}
}
}
}, cancel);
}
}
