/// <summary>
/// Dispara el evento RequestCancelled.
/// </summary>
/// <param name="request">
/// Es el requerimiento que se ha cancelado.
/// </param>
protected virtual void OnRequestCancelled(PeerRequest request)
{
if (RequestCancelled != null)
{
RequestCancelled(this, new PeerRequestCancelledEventArgs(request));
}
}
/// <summary>
/// Dispara el evento RequestDone.
/// </summary>
/// <param name="request">
/// Es el requerimiento que se ha completado.
/// </param>
protected virtual void OnRequestDone(PeerRequest request)
{
if (RequestDone != null)
{
RequestDone(this, new PeerRequestDoneEventArgs(request));
}
}
/// <summary>
/// Crea e inicializa una nueva clase del tipo <see cref="PeerRequestCancelledEventArgs"/>.
/// </summary>
/// <param name="request">
/// Es el requerimiento que se ha completado.
/// </param>
/// <exception cref="ArgumentNullException">
/// request contiene una referencia nula.
/// </exception>
public PeerRequestCancelledEventArgs(PeerRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
_request = request;
}
/// <summary>
/// Dispara el evento <see cref="Receive"/>, luego, si el mensaje
/// recibido es la respuesta a un requerimiento dispara el evento
/// <see cref="RequestDone"/> y finaliza la ejecución del método,
/// en caso contrario invoca a cada procesador de mensajes hasta
/// que alguno lo procese o no hayan mas procesadores de mensajes en
/// la lista.
/// </summary>
/// <param name="message">
/// Es el mensaje que se ha recibido.
/// </param>
protected virtual void OnReceive(Message message)
{
PeerRequest request = null;
// Check if received message is response of a pending request.
if ((_pendingRequests != null))
{
lock ( _pendingRequests ) {
if (_pendingRequests.Count > 0)
{
object messageKey = _messagesIdentifier.ComputeIdentifier(message);
if (messageKey != null)
{
request = ( PeerRequest )_pendingRequests[messageKey];
if (request != null)
{
_pendingRequests.Remove(messageKey);
}
}
}
}
}
if (request == null)
{
// The received message not matched a pending request,
// notify clients via Receive event and peer associated
// processors.
if (Receive != null)
{
Receive(this, new ReceiveEventArgs(message));
}
IMessageProcessor processor = _messageProcessor;
while ((processor != null) &&
!processor.Process(this, message))
{
processor = processor.NextMessageProcessor;
}
}
else
{
// The message is the response of a pending request.
if (request.SetResponseMessage(message))
{
OnRequestDone(request);
}
else
{
// The peer request was signaled as expired by the request timer.
OnRequestCancelled(request);
}
}
}
/// <summary>
/// Cancela un requerimiento en progreso.
/// </summary>
/// <param name="request">
/// Es el requerimiento a cancelar.
/// </param>
internal virtual void Cancel(PeerRequest request)
{
object messageKey = _messagesIdentifier.ComputeIdentifier(
request.RequestMessage);
if (_pendingRequests.Contains(messageKey))
{
lock ( _pendingRequests ) {
if (_pendingRequests.Contains(messageKey))
{
_pendingRequests.Remove(messageKey);
OnRequestCancelled(request);
}
}
}
}
/// <summary>
/// Envía un mensaje del que se espera respuesta.
/// </summary>
/// <param name="request">
/// Es el requerimiento que encapsula el mensaje
/// enviado y el mensaje recibido.
/// </param>
internal virtual void Send(PeerRequest request)
{
object messageKey = _messagesIdentifier.ComputeIdentifier(
request.RequestMessage);
lock ( _pendingRequests ) {
if (_pendingRequests.Contains(messageKey))
{
_pendingRequests.Remove(messageKey);
}
Send(request.RequestMessage);
request.MarkAsTransmitted();
_pendingRequests.Add(messageKey, request);
}
}
/// <summary>
/// It's called to process the indicated message.
/// </summary>
/// <param name="source">
/// It's the source of the message.
/// </param>
/// <param name="message">
/// It's the message to be processed.
/// </param>
/// <returns>
/// A logical value the same to true, if the messages processor
/// processeced it, otherwise it returns false.
/// </returns>
/// <remarks>
/// If the messages processor doesn't process it, the system
/// delivers it to the next processor in the list, and so on until
/// one process it, or there aren't other processors.
///
/// This function handles all the messages received by the server.
/// </remarks>
public bool Process(IMessageSource source, Message message)
{
try {
if ((_peer == null) || !_peer.IsConnected)
{
return(false);
}
PeerRequest request = new PeerRequest(_peer, message);
request.Payload = source;
request.Send(_timeout);
return(true);
}
catch (Exception e) {
Logger.Error(e);
return(false);
}
}
