Example #1
0
        public Node(Int32 identity,
                    String name,
                    //NodeSignalsWorker udpSignalsWorker,
                    NodeMainTCPSignalWorker tcpSignalsWorker,
                    NodeCommandSignalWorker cmdSignalsWorker)
        {
            Identity = identity;
            Name     = name;

            InMessageBuffer  = new BufferBlock <IList <Byte[]> >();
            OutMessageBuffer = new BufferBlock <(Node Node, IList <Byte[]> Msg)>();

            CommandInMessageBuffer  = new BufferBlock <IList <Byte[]> >();
            CommandOutMessageBuffer = new BufferBlock <(Int32 Node, IList <Byte[]> Msg)>();

            TCPSocketSignalsWorker = tcpSignalsWorker;
            //UDPSocketSignalsWorker = udpSignalsWorker;
            CMDSocketSignalsWorker = cmdSignalsWorker;
        }
        public void ProcessMessage(MessageData message)
        {
            switch (message.Type)
            {
            case MessageType.Common:
                OnNormalMessage();
                return;

            case MessageType.NodeSignal:
                OnNodeSignalMessage();
                return;

            case MessageType.NodeInitialization:
                OnNewNode();
                return;
            }


            void OnNewNode()
            {
                var nodeName = MessageCodec.DecodeNodeInitialization(message.Data);

                //var udpSigWorker = new NodeSignalsWorker(message.Identity, m_signalsProcessor.SendSignalBuffer);
                var tcpSigWorker = new NodeMainTCPSignalWorker(message.Identity, m_signalsProcessor.SendSignalBuffer);
                var cmdSigWorker = new NodeCommandSignalWorker(message.Identity, m_signalsProcessor.SendSignalBuffer);

                var node = new Node(message.Identity,
                                    nodeName,
                                    //udpSigWorker,
                                    tcpSigWorker,
                                    cmdSigWorker);

                m_nodes.Add(message.Identity, node);
                node.OutMessageBuffer.LinkTo(SendMessageBuffer);
                node.CommandOutMessageBuffer.LinkTo(SendCommandBuffer);

                NodeRegistered?.Invoke(this, new NodeRegisteredEventArgs(node));

                node.TCPSocketSignalsWorker.SendNullSignal();
            }

            void OnNodeSignalMessage()
            {
                if (m_nodes.TryGetValue(message.Identity, out var node))
                {
                    m_signalsProcessor.RecvSignalBuffer.Post((                                //(message.Protocol == TransportProtocol.TCP) ?
                                                                 node.TCPSocketSignalsWorker, //:
                                                                 //node.UDPSocketSignalsWorker,
                                                                 message.Data));
                }
                else
                {
                    OnUninitializedMessage();
                }
            }

            void OnNormalMessage()
            {
                if (m_nodes.TryGetValue(message.Identity, out var node))
                {
                    node.InMessageBuffer.Post(message.Data);
                }
                else
                {
                    OnUninitializedMessage();
                }
            }
        }