/// <summary>
/// Initializes a new instance of the <see cref="ReceivedMessageEventArgs" /> class.
/// </summary>
/// <param name="message">The message that was received.</param>
public ReceivedMessageEventArgs(Message message)
{
_message = message;
}
/// <summary>
/// Updates the response and response result.
/// </summary>
/// <param name="result">The result of waiting for the response.</param>
/// <param name="response">The response message.</param>
internal void ResponseReceived(ResponseResults result, Message response)
{
lock (_lockObject)
{
_responseResult = result;
_responseMessage = response;
_progress = MessageResponseProgress.Completed;
}
}
/// <inheritdoc></inheritdoc>
protected override void ReceivedSystemMessage(Message message)
{
// Do nothing, there are no system messages used in a mesh network.
}
/// <summary>
/// Called when a neighbor message is received.
/// </summary>
/// <param name="message">The message received.</param>
private void ReceivedNeighborsMessage(Message message)
{
if (message.AwaitingResponse)
{
// request for information
var builder = new StringBuilder();
foreach (var item in GetNeighbors())
{
builder.Append(item.IpAddress);
builder.Append(":");
builder.Append(item.Port);
builder.Append(";");
}
if (builder.Length == 0)
{
builder.Append(";");
}
SendResponseInternal(message, MessageType.Neighbors, builder.ToString());
}
}
/// <summary>
/// Called when a ping message is received.
/// </summary>
/// <param name="message">The message received.</param>
private void ReceivedPing(Message message)
{
NetworkConnection connection = GetApprovedNetworkConnection(message.Sender);
if (connection != null)
{
connection.LastPingReceived = DateTime.UtcNow;
}
}
/// <summary>
/// Called when an approval message is received.
/// </summary>
/// <param name="message">The message that was received.</param>
private void ReceivedApprovalMessage(Message message)
{
if (message.AwaitingResponse)
{
if (message.Data == GetNetworkType())
{
// Setup a connection to the sender so that we can approve it.
Task.WaitAll(GetUnapprovedNetworkConnection(message.Sender));
lock (_sendingLockObject)
{
if (_sendingConnections.ContainsKey(message.Sender) && _sendingConnections[message.Sender] != null)
{
_sendingConnections[message.Sender].Approved = true;
}
}
SendResponseInternal(message, MessageType.Approval, "approved");
lock (_recentlyApprovedNodesLockObject)
{
_recentlyApprovedNodes.Enqueue(new ApprovedNodeDetails(message.Sender, true));
}
}
else
{
SendResponseInternal(message, MessageType.Approval, "failure");
}
}
}
/// <summary>
/// Processes all received messages.
/// </summary>
private void ProcessMessages()
{
while (_receivedMessages.Count > 0)
{
var messageObject = _receivedMessages.Dequeue();
var message = new Message(
messageObject.Item1.Sender,
messageObject.Item1.Data,
messageObject.Item1.MessageId,
messageObject.Item1.WaitingForResponse,
messageObject.Item1.InResponseToMessage);
_logger.Write("Message received, " + messageObject.Item1, LogLevels.Debug);
if (message.InResponseToMessage)
{
lock (_responsesLockObject)
{
_responses[message.MessageId] = message;
}
}
switch (messageObject.Item1.Type)
{
case MessageType.Approval:
ReceivedApprovalMessage(message);
break;
case MessageType.Neighbors:
ReceivedNeighborsMessage(message);
break;
case MessageType.Ping:
ReceivedPing(message);
break;
case MessageType.System:
ReceivedSystemMessage(message);
break;
case MessageType.User:
if (ReceivedMessage != null)
{
ReceivedMessage(this, new ReceivedMessageEventArgs(message));
}
break;
case MessageType.Unknown:
break;
}
}
}
/// <summary>
/// Sends a response message to a node.
/// </summary>
/// <param name="responseTo">The message that this message is in response to.</param>
/// <param name="type">The type of message to send.</param>
/// <param name="message">The message to send.</param>
/// <returns>A value indicating whether the message was successfully sent.</returns>
protected MessageSendResult SendResponseInternal(Message responseTo, MessageType type, string message)
{
var result = new MessageSendResult();
var composedMessage = InternalMessage.CreateResponseMessage(
responseTo.Sender,
new NodeProperties("localhost", _port),
type,
message,
responseTo.MessageId,
result);
lock (_messagesToSendLockObject)
{
_messagesToSend.Enqueue(composedMessage);
}
return result;
}
/// <summary> /// Called when a system message is received. /// </summary> /// <param name="message">The message that was received.</param> protected abstract void ReceivedSystemMessage(Message message);
/// <summary>
/// Sends a message response.
/// </summary>
/// <param name="responseTo">The message that is being responded to.</param>
/// <param name="message">The message to send.</param>
/// <returns>A value indicating whether the message was successfully sent.</returns>
public MessageSendResult SendResponse(Message responseTo, string message)
{
return SendResponseInternal(responseTo, MessageType.User, message);
}
