Пример #1
0
        protected override async Task OnClientDataReceived(IPeerProxy client, byte[] data)
        {
            Stream           stream       = new MemoryStream(data);
            PeerPacketHeader packetHeader = stream.DeserializePeerPacketHeader();

            switch ((PacketType)packetHeader.Type)
            {
            case PacketType.System:
            {
                HandleSystemPacket(client, stream);
            }
            break;

            case PacketType.Post:
            {
                HandlePostPacket(client, stream);
            }
            break;

            case PacketType.Vote:
            {
                HandleVotePacket(stream);
            }
            break;
            }
        }
Пример #2
0
        public Task WriteTo <T>(IPeerProxy peer, T data)
        {
            if (!ConnectedPeersProxy.Contains(peer))
            {
                throw new ArgumentException($"Unknown peerClient: {peer}");
            }

            RawPacket rawPacket = new RawPacket();

            rawPacket.Payload = PreparePeerData(peer, data);
            rawPacket.MAC     = Hasher.ComputeHash(rawPacket.Payload);
            byte[] serializedPacket = rawPacket.SerializeToBuffer();
            return(peer.SendAsync(serializedPacket));
        }
Пример #3
0
        protected override async Task OnClientDataReceived(IPeerProxy client, byte[] data, int bytesRead)
        {
            PeerPacketHeader packetHeader = data.DeserializePeerPacketHeader();

            switch ((MessageType)packetHeader.Type)
            {
            case MessageType.SYSTEM:
            {
            }
            break;

            case MessageType.MSG:
            {
            }
            break;

            case MessageType.VOTE:
            {
                PeerPacket <Vote> votePacket = data.DeserializePeerPacket <Vote>();
                Vote vote = votePacket.Payload;
                switch (vote.Ogranization)
                {
                case OrganizationType.Union:
                    break;

                case OrganizationType.Company:
                    break;

                case OrganizationType.Village:
                    break;

                case OrganizationType.City:
                    break;

                case OrganizationType.Government:
                    break;

                case OrganizationType.Country:
                    break;

                case OrganizationType.Anonymous:
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
            break;
            }
        }
Пример #4
0
        protected override byte[] PreparePeerData <T>(IPeerProxy peer, T data)
        {
            byte[] result = null;
            var    packetTypeAttribute = (PacketTypeAttribute)data.GetType()
                                         .GetCustomAttributes(typeof(PacketTypeAttribute), true)
                                         .FirstOrDefault();

            if (packetTypeAttribute != null)
            {
                PeerPacket <T> votePacket = new PeerPacket <T>();
                votePacket.Header.Type      = (ulong)packetTypeAttribute.PacketType;
                votePacket.Header.FromPoint = PeerId;
                votePacket.Header.ToPoint   = peer.PeerId;
                votePacket.Payload          = data;
                result = votePacket.SerializePeerPacket();
            }
            return(result);
        }
Пример #5
0
        private void HandleSystemPacket(IPeerProxy client, Stream data)
        {
            PeerPacket <Networking.Messages.System> systemPacket = data.DeserializePeerPacket <Networking.Messages.System>();

            Networking.Messages.System systemInfo = systemPacket.Payload;
            SystemType systemEvent = systemInfo.SystemEvent;

            switch (systemEvent)
            {
            case SystemType.CREATE_NEW_BLOCK:
                break;

            case SystemType.FIND_BLOCK:
                break;

            case SystemType.READ_BLOCK:
                break;
            }
        }
Пример #6
0
        protected async Task OnDataReceived(IPeerProxy peer, byte[] data)
        {
            var readMessage = ReadPeersProxy[peer];

            readMessage.AddRange(new List <byte>(data));
            try
            {
                RawPacket rawPacket = readMessage.DeserializeRawPacket();
                if (IsMacEquals(Hasher.ComputeHash(rawPacket.Payload), rawPacket.MAC))
                {
                    Console.WriteLine("RawPacket is valid. Let's process it ...");
                    await OnClientDataReceived(peer, rawPacket.Payload);
                }
                readMessage.Clear();
            }
            catch (SerializationException ex)
            {
                Console.WriteLine($"SerializationException ex: {ex}");
            }
        }
Пример #7
0
        private void HandlePostPacket(IPeerProxy client, Stream data)
        {
            PeerPacket <Post> postPacket = data.DeserializePeerPacket <Post>();

            _nextBlockToCreate.Add(PacketType.Post, postPacket.Payload);
        }
        // Used to retrieve a neighbor given the proxy.
        // Maps the proxy from the incoming message's service context to a neighbor instance.
        public IPeerNeighbor GetNeighborFromProxy(IPeerProxy proxy)
        {
            PeerNeighbor neighbor = null;

            lock (ThisLock)
            {
                if (state == State.Opened)
                {
                    // Find the neighbor containing the specified proxy.
                    foreach (PeerNeighbor nbr in this.neighborList)
                    {
                        if (nbr.Proxy == proxy)
                        {
                            neighbor = nbr;
                            break;
                        }
                    }
                }
            }

            return neighbor;
        }
 // Open an accepting (incoming) neighbor. callbackInstance is where msgs meant for
 // remote endpoint should be sent.
 public void Open(IPeerProxy callbackInstance)
 {
     this.initiator = false;
     this.Proxy = callbackInstance;
 }
 public IpcRequestMessageContext(IpcBufferMessage ipcBufferMessage, IPeerProxy peer)
 {
     IpcBufferMessage = ipcBufferMessage;
     Peer             = peer;
 }