Пример #1
0
        /// <summary>
        /// Processes a message.
        /// </summary>
        /// <param name="address">The address the message was sent from.</param>
        /// <param name="data">The data to be decoded and processed.</param>
        private void ProcessMessage(NodeDefinition address, byte[] data)
        {
            Message message = new Message(address, data);

            Logger.Log("Received message of type " + message.Data.GetType().Name + " from " + message.Address.ConnectionName, LogLevel.Debug);

            // If the message is in response to another message, then don't send an event.
            // Also, if the message is a Heartbeat, we don't need to do anything,
            // the last connection time should have been updated when it was received.
            if (message.InResponseTo != 0)
            {
                lock (_waitingForResponses)
                {
                    if (_waitingForResponses.ContainsKey(message.InResponseTo))
                    {
                        Message waiting = _waitingForResponses[message.InResponseTo].Item1;
                        waiting.Response = message;
                        waiting.Status   = MessageStatus.ResponseReceived;
                        if (waiting.ResponseCallback != null)
                        {
                            _messageReceivedThreadPool.QueueWorkItem(waiting.ResponseCallback, waiting);
                        }

                        _waitingForResponses.Remove(message.InResponseTo);
                    }
                }
            }
            else if (!(message.Data is Heartbeat))
            {
                _messageReceivedThreadPool.QueueWorkItem(MessageReceivedHandler, message);
            }
        }
Пример #2
0
        /// <summary>
        /// Marks the connection as established.
        /// </summary>
        /// <param name="def">The node definition, only used for logging at the moment.</param>
        /// <param name="type">The node type that the connection is to.</param>
        public void ConnectionEstablished(NodeDefinition def, NodeType type)
        {
            NodeType = type;
            Status   = ConnectionStatus.Connected;

            Logger.Log("Connected to " + Enum.GetName(typeof(NodeType), type) + " node at " + def.ConnectionName, LogLevel.Info);
        }
Пример #3
0
        /// <summary>
        /// Process a connection request.
        /// </summary>
        /// <param name="result">The result of the connection listener.</param>
        private void ProcessConnectionRequest(IAsyncResult result)
        {
            TcpClient incoming;

            try
            {
                incoming = _connectionListener.EndAcceptTcpClient(result);
                _connectionListener.BeginAcceptTcpClient(ProcessConnectionRequest, null);
            }
            catch (ObjectDisposedException)
            {
                // The connection listener was shutdown, stop the async loop.
                return;
            }

            Connection connection = new Connection(incoming);

            _connectionsLock.EnterWriteLock();

            NodeDefinition def = new NodeDefinition(((IPEndPoint)incoming.Client.RemoteEndPoint).Address.ToString(), ((IPEndPoint)incoming.Client.RemoteEndPoint).Port);

            _connections.Add(def, connection);

            _connectionsLock.ExitWriteLock();
        }
Пример #4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Message"/> class.
 /// </summary>
 /// <param name="address">The address the message is to be sent to.</param>
 /// <param name="data">The data to be sent in the message.</param>
 /// <param name="waitingForResponse">Whether the message is waiting for a response.</param>
 public Message(NodeDefinition address, BaseMessageData data, bool waitingForResponse)
 {
     _address            = address;
     _data               = data;
     _status             = MessageStatus.Created;
     _id                 = GetNextId();
     _waitingForResponse = waitingForResponse;
 }
Пример #5
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Message"/> class.
 /// </summary>
 /// <param name="responseTo">The message this is in response to.</param>
 /// <param name="data">The data to be sent in the message.</param>
 /// <param name="waitingForResponse">Whether the message is waiting for a response.</param>
 public Message(Message responseTo, BaseMessageData data, bool waitingForResponse)
 {
     _address            = responseTo.Address;
     _inResponseTo       = responseTo._id;
     _data               = data;
     _status             = MessageStatus.Created;
     _id                 = GetNextId();
     _waitingForResponse = waitingForResponse;
 }
Пример #6
0
        /// <summary>
        /// Renames a connection.
        /// </summary>
        /// <param name="currentName">The current name of the connection.</param>
        /// <param name="newName">The new name of the connection.</param>
        protected void RenameConnection(NodeDefinition currentName, NodeDefinition newName)
        {
            if (Equals(currentName, newName))
            {
                return;
            }

            // MAKE SURE THIS LOCK ORDER IS THE SAME EVERYWHERE
            _connectionsLock.EnterWriteLock();
            lock (_messagesReceived)
            {
                if (_connections.ContainsKey(currentName))
                {
                    // Most likely means that a node disconnected and is trying to reconnect before the connection timeout time.
                    if (_connections.ContainsKey(newName))
                    {
                        _connections.Remove(newName);
                    }

                    if (_messagesReceived.ContainsKey(newName))
                    {
                        _messagesReceived.Remove(newName);
                    }

                    var connectionValue = _connections[currentName];
                    _connections.Remove(currentName);
                    _connections.Add(newName, connectionValue);

                    if (_messagesReceived.ContainsKey(currentName))
                    {
                        var messageValue = _messagesReceived[currentName];
                        _messagesReceived.Remove(currentName);
                        _messagesReceived.Add(newName, messageValue);
                    }
                }
            }

            _connectionsLock.ExitWriteLock();
        }
Пример #7
0
 /// <summary>
 /// Called when a connection is lost.
 /// </summary>
 /// <param name="node">The connection that was lost.</param>
 /// <param name="type">The node type that was lost.</param>
 protected abstract void ConnectionLost(NodeDefinition node, NodeType type);
Пример #8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Message"/> class.
 /// </summary>
 /// <param name="address">The address this message is from.</param>
 /// <param name="data">The message data to decode.</param>
 internal Message(NodeDefinition address, byte[] data)
 {
     _address = address;
     DecodeMessage(data);
     _status = MessageStatus.Received;
 }