public BackgroundWorker(IMessageExchanger messageExchanger, IMessageGenerator messageGenerator,
IComponentDrawer networkDrawer, IMessageCreator messageCreator,
IMessageRegistrator messageRegistrator, IMessageViewUpdater messageViewUpdated,
int updatePeriod)
{
_messageExchanger = messageExchanger;
_messageGenerator = messageGenerator;
_networkDrawer = networkDrawer;
_messageCreator = messageCreator;
_messageRegistrator = messageRegistrator;
_updatePeriod = updatePeriod;
_messageViewUpdated = messageViewUpdated;
_locker = new Mutex();
}
/// <summary>
/// Processes incoming requests and responses.
/// </summary>
/// <param name="stream">The stream containing a request or a response.</param>
/// <param name="remote">The remote host.</param>
/// <param name="genuineConnectionType">The type of the connection.</param>
/// <param name="connectionName">Connection id to send a response through.</param>
/// <param name="dbgConnectionId">The identifier of the connection, which is used for debugging purposes only.</param>
/// <param name="useThisThread">True to invoke the target in the current thread.</param>
/// <param name="iMessageRegistrator">The message registrator.</param>
/// <param name="connectionLevelSecuritySession">Connection Level Security Session.</param>
/// <param name="httpServerRequestResult">The HTTP request through which the message was received.</param>
/// <returns>True if it's a one-way message.</returns>
public bool HandleMessage(Stream stream, HostInformation remote, GenuineConnectionType genuineConnectionType, string connectionName, int dbgConnectionId, bool useThisThread, IMessageRegistrator iMessageRegistrator, SecuritySession connectionLevelSecuritySession, HttpServerRequestResult httpServerRequestResult)
{
// read the Security Session name
BinaryReader binaryReader = new BinaryReader(stream);
string sessionName = binaryReader.ReadString();
Message message = null;
BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter;
// and decode the packet
SecuritySession securitySession = remote.GetSecuritySession(sessionName, this.ITransportContext.IKeyStore);
if (securitySession == null)
{
// LOG:
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Security] > 0 )
{
binaryLogWriter.WriteEvent(LogCategory.Security, "GenuineReceivingHandler.HandleMessage",
LogMessageType.SecuritySessionApplied, GenuineExceptions.Get_Security_ContextNotFound(sessionName),
message, remote,
null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
securitySession, sessionName, dbgConnectionId,
0, 0, 0, null, null, null, null,
"The requested Security Session can not be constructed or established. The name of Security Session: {0}.",
sessionName);
}
this.ITransportContext.IGenuineEventProvider.Fire(new GenuineEventArgs(GenuineEventType.SecuritySessionWasNotFound, GenuineExceptions.Get_Security_ContextNotFound(sessionName),
remote, null));
return true;
}
// decode the stream and roll back if it was a Security Session's message
stream = securitySession.Decrypt(stream);
if (stream == null)
return true;
// read the message
message = MessageCoder.Deserialize(stream, sessionName);
message.ConnectionName = connectionName;
message.SecuritySessionParameters._connectionName = connectionName;
message.SecuritySessionParameters._genuineConnectionType = genuineConnectionType;
message.Sender = remote;
message.ITransportContext = this.ITransportContext;
message.ConnectionLevelSecuritySession = connectionLevelSecuritySession;
message.HttpServerRequestResult = httpServerRequestResult;
// LOG:
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Security] > 0 )
{
binaryLogWriter.WriteEvent(LogCategory.Security, "GenuineReceivingHandler.HandleMessage",
LogMessageType.SecuritySessionApplied, null, message, remote,
null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
securitySession, sessionName, dbgConnectionId,
0, 0, 0, null, null, null, null,
"The Security Session has been used for decrypting the message.");
}
// LOG:
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
{
bool readContent = this.ITransportContext.BinaryLogWriter[LogCategory.MessageProcessing] > 1;
if (readContent)
{
GenuineChunkedStream streamClone = new GenuineChunkedStream();
GenuineUtility.CopyStreamToStream(message.Stream, streamClone);
message.Stream = streamClone;
}
binaryLogWriter.WriteMessageCreatedEvent("GenuineReceivingHandler.HandleMessage",
LogMessageType.MessageReceived, null, message, message.ReplyToId > 0, remote,
readContent ? message.Stream : null,
message.ITransportHeaders[Message.TransportHeadersInvocationTarget] as string, message.ITransportHeaders[Message.TransportHeadersMethodName] as string,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, connectionName, dbgConnectionId,
connectionLevelSecuritySession == null ? -1 : connectionLevelSecuritySession.SecuritySessionId,
connectionLevelSecuritySession == null ? null : connectionLevelSecuritySession.Name,
securitySession == null ? -1 : securitySession.SecuritySessionId,
securitySession.Name,
"The message has been received.");
}
if (message.ReplyToId == PING_MESSAGE_REPLYID)
return true;
if (iMessageRegistrator != null && iMessageRegistrator.WasRegistered(remote.Uri, message.MessageId, message.ReplyToId))
{
// LOG:
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineReceivingHandler.HandleMessage",
LogMessageType.MessageDispatched, GenuineExceptions.Get_Debugging_GeneralWarning("The message has been already processed."), message, remote,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, securitySession, securitySession.Name,
dbgConnectionId,
GenuineUtility.TickCount, 0, message.SeqNo, null, null, null, null,
"The message has been already processed. Therefore, this message is ignored.");
return true;
}
// if it's a response, then direct the message to the response handler
if (message.ReplyToId > 0)
{
message.IsOneWay = true;
IResponseProcessor iResponseProcessor = GenuineReceivingHandler._responseHandlers[message.ReplyToId] as IResponseProcessor;
// nothing waits for this request
if (iResponseProcessor == null)
return true;
// 2.5.1: set the answer flag
if (iResponseProcessor.Message != null)
iResponseProcessor.Message.HasBeenAsnwered = true;
if (iResponseProcessor.IsShortInProcessing)
{
iResponseProcessor.ProcessRespose(message);
#if TRIAL
#else
if (iResponseProcessor.IsExpired(GenuineUtility.TickCount))
GenuineReceivingHandler._responseHandlers.Remove(message.ReplyToId);
#endif
return true;
}
}
// take care about the thread and call context
if (useThisThread)
InternalExecuteMessage(message);
else
GenuineThreadPool.QueueUserWorkItem(this._waitCallback_InternalExecuteMessagewaitCallback, message, false);
return message.IsOneWay;
}
private void InitializeAllServices(double messageGenerateChance, int tableUpdatePeriod,
bool isPackageMode, bool isRouterStupid, int messagesSize)
{
if (isRouterStupid)
{
_messageRouter = new IndependentMessageRouter(_network);
}
else
{
_messageRouter = new MessageRouter(_network);
}
if (isPackageMode)
{
_messageCreator = new PackageMessageCreator(_network, _messageRouter);
}
else
{
_messageCreator = new RequestMessageCreator(_network, _messageRouter);
}
_positiveResponseMessageCreator = new PositiveResponseCreator(_network, _messageRouter);
_negativeResponseMessageCreator = new NegativeResponseCreator(_network, _messageRouter);
_messageHandler = new MessageHandler(_network, _messageCreator, _positiveResponseMessageCreator);
_messageReceiver = new MessageReceiver(_messageHandler, _negativeResponseMessageCreator);
_messageExchanger = new MessageExchanger(_network, _messageReceiver);
if (messagesSize > 0)
{
_messageGenerator = new SpecifiedSizeMessageGenerator(_network, _messageCreator, messageGenerateChance,
messagesSize);
}
else
{
_messageGenerator = new MessageGenerator(_network, _messageCreator, messageGenerateChance);
}
_messageRepository = new MessageRepository(_network);
_messageViewUpdater = new MessageViewUpdater(_messageRepository, Messages);
_messageRegistrator = new MessageRegistrator(_messageRepository);
_messagesStatisticCounter = new MessagesStatisticCounter(_messageRegistrator, _messageRepository);
_backgroundWorker = new Background.BackgroundWorker(_messageExchanger, _messageGenerator,
_networkDrawer, _messageCreator, _messageRegistrator, _messageViewUpdater, tableUpdatePeriod);
_messageCreator.UpdateTables();
FiltrationModeSelect_OnSelectionChanged(FiltrationModeSelect, null);
_backgroundWorker.Run();
_backgroundWorker.Interval = IntervalSlider.Value;
_headerUpdater = new DispatcherTimer
{
Interval = TimeSpan.FromMilliseconds(IntervalSlider.Value)
};
_headerUpdater.Tick += (sender, args) => Title = $"Coursework (time: {_backgroundWorker.Ticks})";
_headerUpdater.Start();
}
public MessagesStatisticCounter(IMessageRegistrator messageRegistrator, IMessageRepository messageRepository)
{
_messageRegistrator = messageRegistrator;
_messageRepository = messageRepository;
}
