/// <summary>Parameterized constructor.
/// </summary>
/// <param name="loggerFactory"></param>
public DefaultActionExecutionService(ILoggerFactory loggerFactory)
{
_logger = loggerFactory.Create(GetType().Name);
_actionQueue = new BlockingCollection<ActionInfo>(new ConcurrentQueue<ActionInfo>());
_worker = new Worker(TryTakeAndExecuteAction, DefaultPeriod);
_worker.Start();
}
/// <summary>Parameterized constructor.
/// </summary>
/// <param name="eventHandlerTypeCodeProvider"></param>
/// <param name="eventHandlerProvider"></param>
/// <param name="eventPublishInfoStore"></param>
/// <param name="eventHandleInfoStore"></param>
/// <param name="eventHandleInfoCache"></param>
/// <param name="actionExecutionService"></param>
/// <param name="loggerFactory"></param>
public DefaultEventProcessor(
IEventHandlerTypeCodeProvider eventHandlerTypeCodeProvider,
IEventHandlerProvider eventHandlerProvider,
IEventPublishInfoStore eventPublishInfoStore,
IEventHandleInfoStore eventHandleInfoStore,
IEventHandleInfoCache eventHandleInfoCache,
IActionExecutionService actionExecutionService,
ILoggerFactory loggerFactory)
{
_eventHandlerTypeCodeProvider = eventHandlerTypeCodeProvider;
_eventHandlerProvider = eventHandlerProvider;
_eventPublishInfoStore = eventPublishInfoStore;
_eventHandleInfoStore = eventHandleInfoStore;
_eventHandleInfoCache = eventHandleInfoCache;
_actionExecutionService = actionExecutionService;
_logger = loggerFactory.Create(GetType().Name);
_queueList = new List<BlockingCollection<EventProcessingContext>>();
for (var index = 0; index < WorkerCount; index++)
{
_queueList.Add(new BlockingCollection<EventProcessingContext>(new ConcurrentQueue<EventProcessingContext>()));
}
_workerList = new List<Worker>();
for (var index = 0; index < WorkerCount; index++)
{
var queue = _queueList[index];
var worker = new Worker(() =>
{
DispatchEventsToHandlers(queue.Take());
});
_workerList.Add(worker);
worker.Start();
}
}
public void Start(Action<ReceiveContext> messageReceivedCallback)
{
if (_isRunning) return;
_isRunning = true;
_listenNewClientWorker = new Worker("ServerSocket.AcceptNewClient", () =>
{
if (!_isRunning) return;
_messageReceivedCallback = messageReceivedCallback;
_newClientSocketSignal.Reset();
try
{
_socket.BeginAccept((asyncResult) =>
{
if (!_isRunning) return;
var clientSocket = _socket.EndAccept(asyncResult);
var socketInfo = new SocketInfo(clientSocket);
NotifyNewSocketAccepted(socketInfo);
_newClientSocketSignal.Set();
if (!_isRunning) return;
_socketService.ReceiveMessage(socketInfo, receivedMessage =>
{
var receiveContext = new ReceiveContext(socketInfo, receivedMessage, context =>
{
_socketService.SendMessage(context.ReplySocketInfo, context.ReplyMessage, sendResult => { });
});
_messageReceivedCallback(receiveContext);
});
}, _socket);
}
catch (SocketException socketException)
{
_logger.Error(string.Format("Socket accept exception, ErrorCode:{0}", socketException.SocketErrorCode), socketException);
}
catch (Exception ex)
{
_logger.Error("Unknown socket accept exception.", ex);
}
if (_isRunning)
{
_newClientSocketSignal.WaitOne();
}
});
_listenNewClientWorker.Start();
}
