public void Produce(string key, T value, long expireAt = long.MaxValue) { byte[] packet = LZ4MessagePackSerializer.Serialize(new Packet { Command = "PUSH", Key = key, Value = LZ4MessagePackSerializer.Serialize(value), ExpireAt = expireAt }); peer.Send(packet); }
public async Task Handle(BlockHeadersMessage message, IPeer sender) { var lastBlockHeaderIndex = _blockchain.LastBlockHeader.Index; var missingBlockHeaders = (message.Payload.Headers ?? new BlockHeader[0]) .Where(h => h != null && h.Index > lastBlockHeaderIndex) .Distinct(h => h.Index) .ToList(); if (missingBlockHeaders.Count == 0) { return; } await _blockchain.AddBlockHeaders(missingBlockHeaders); // TODO: Find a better place for block sync var missingBlockHashes = missingBlockHeaders .Select(bh => bh.Hash) .Where(bh => bh != null) .ToList(); await SynchronizeBlocks(missingBlockHashes, sender); if (_blockchain.LastBlockHeader.Index < sender.Version.CurrentBlockIndex) { _logger.LogInformation($"The peer has {sender.Version.CurrentBlockIndex + 1} blocks but the current number of block headers is {_blockchain.LastBlockHeader.Index + 1}."); await sender.Send(new GetBlockHeadersMessage(_blockchain.LastBlockHeader.Hash)); } }
/// <summary> /// 메세지를 브로드캐스팅 한다. /// </summary> /// <param name="accountId">계정</param> /// <param name="message">메세지</param> public void Broadcast(string accountId, string message) { cPKTSayNotify sendPacket = new cPKTSayNotify(); sendPacket.AccountId = accountId; sendPacket.Message = message; cLogger.Information("Broadcast AccountId: {0}, Message: {1}\r\n", accountId, message); StringBuilder log = new StringBuilder(); foreach (KeyValuePair <string, IPeer> pair in PeerMap) { log.AppendFormat("AccountId: {0}, ", pair.Value.PeerId); } cLogger.Information("ChatRoom Member =====> {0}\r\n", log.ToString()); Parallel.ForEach(PeerMap, pair => { IPeer peer = pair.Value; if (null != peer) { peer.Send(sendPacket); } }); }
public void Execute(IPeer peer, IPacket packet) { cPKTChatLogin recvPacket = (cPKTChatLogin)packet; cPKTChatLoginResult resultPacket = new cPKTChatLoginResult(); do { if (0 == recvPacket.AccountId.Length) { resultPacket.ResultCode = cPKTChatLoginResult.eResultCode.TOO_SHORT_ACCOUNT_ID; break; } cChatPlayer chatPlayer = (cChatPlayer)peer; chatPlayer.AccountId = recvPacket.AccountId; cLogger.Information("a peer is added (account_id: {0})\r\n", chatPlayer.AccountId); peer.PeerId = chatPlayer.AccountId; cPeerRegistry.Instance.Add(peer); cLogger.Information("join to chatroom (account_id: {0})\r\n", chatPlayer.AccountId); int retChatRoomNumber = cChatRoomManager.Join(recvPacket.AccountId, peer); resultPacket.ResultCode = cPKTChatLoginResult.eResultCode.SUCCEED; resultPacket.ChatRoomNumber = retChatRoomNumber; } while (false); peer.Send(resultPacket); }
public void StartFor(IPeer peer, CancellationToken cancellationToken) { // Initiate handshake peer.Send(new VersionMessage(_serverContext.Version)); Task.Factory.StartNew(async() => { while (peer.IsConnected) { var message = await peer.Receive(); if (message == null) { await _asyncDelayer.Delay(DefaultMessagePollingInterval, cancellationToken); continue; } // TODO: Peer that sending wrong messages has to be disconnected. if (peer.IsReady == message.IsHandshakeMessage()) { continue; } await _messageHandler.Handle(message, peer); } }, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default); }
/// <summary> /// Handle Inventory message /// </summary> /// <param name="message">Message</param> /// <param name="sender">Sender</param> /// <returns>Task</returns> public Task Handle(InventoryMessage message, IPeer sender) { var inventoryType = message.Payload.Type; if (Enum.IsDefined(typeof(InventoryType), inventoryType) == false) { _logger.LogError($"The payload of {nameof(InventoryMessage)} contains unknown {nameof(InventoryType)} \"{inventoryType}\"."); return(Task.CompletedTask); } var hashes = message.Payload.Hashes .Distinct() .ToArray(); // TODO: exclude known hashes if (!hashes.Any()) { _logger.LogWarning($"The payload of {nameof(InventoryMessage)} contains no hashes."); return(Task.CompletedTask); } return(sender.Send(new GetDataMessage(inventoryType, hashes))); }
public async Task Handle(GetBlockHashesMessage message, IPeer sender) { var blockHash = message.Payload.HashStart .Select(p => _blockchain.GetBlockHeader(p)) .Where(p => p != null) .OrderBy(p => p.Index) .Select(p => p.Hash) .FirstOrDefault(); if (blockHash == null || blockHash == message.Payload.HashStop) { return; } var blockHashes = new List <UInt256>(); do { blockHash = _blockchain.GetNextBlockHash(blockHash); if (blockHash == null || blockHash == message.Payload.HashStop) { break; } blockHashes.Add(blockHash); } while (blockHash != message.Payload.HashStop && blockHashes.Count < MaxBlockHeadersCountToReturn); if (blockHashes.Count == 0) { return; } await sender.Send(new InventoryMessage(InventoryType.Block, blockHashes)); }
private async Task SendBlocks(IReadOnlyCollection <UInt256> blockHashes, IPeer peer) { var blocks = await _blockchain.GetBlocks(blockHashes); if (!blocks.Any()) { return; } var filter = peer.BloomFilter; if (filter == null) { // TODO: The more efficient operation would be to send many blocks per one message // but it breaks backward compatibility await Task.WhenAll(blocks.Select(b => peer.Send(new BlockMessage(b)))); } else { var merkleBlocks = blocks .ToDictionary( b => b, b => new BitArray(b.Transactions .Select(tx => TestFilter(filter, tx)) .ToArray() ) ); // TODO: Why don't we have this message? // await peer.Send(new MerkleBlockMessage(merkleBlocks)); } }
private void Sync(IPeer peer = null) { Flush(actions => { peer?.Send(new Packet(0, actions)); }); }
private async Task SendTransactions(IReadOnlyCollection <UInt256> transactionHashes, IPeer peer) { var transactions = await _blockchain.GetTransactions(transactionHashes); // TODO: The more efficient operation would be to send many transactions per one message // but it breaks backward compatibility await Task.WhenAll(transactions.Select(t => peer.Send(new TransactionMessage(t)))); }
protected virtual void OnPeerJoinResponse(IPeer peer, JoinGroupResponse response) { GenericPacket packet = new GenericPacket(); packet.InstCode = SimpleGameMetrics.OperationCode.Group; packet.Data = response; byte[] dgram = serializer.Serialize(packet); peer.Send(dgram, Reliability.ReliableOrder); }
/// <inheritdoc /> public override async Task Handle(MemPoolMessage message, IPeer sender) { var hashes = _transactionPool .Take(InventoryPayload.MaxHashes) .Select(tx => tx.Hash) .ToArray(); await sender.Send(new InventoryMessage(InventoryType.Transaction, hashes)); }
/// <summary> /// Handle GetMemPool message /// </summary> /// <param name="message">Message</param> /// <param name="sender">Sender</param> /// <returns>Task</returns> public async Task Handle(MemPoolMessage message, IPeer sender) { var hashes = _blockchain.MemoryPool .Peek(InventoryPayload.MaxHashes) .Select(tx => tx.Value.Hash) .ToArray(); await sender.Send(new InventoryMessage(InventoryType.Transaction, hashes)); }
public void Send(string message) { var buffer = _ToBytes(message); _Peer.Send(buffer, 0, buffer.Length).DoneEvent += (send_count) => { _Viewer.WriteLine(string.Format("send bytes {0} ", send_count)); }; }
protected override void OnPeerJoinResponse(IPeer peer, JoinGroupResponse response) { GenericPacket packet = new GenericPacket(); packet.InstCode = SimpleGameMetrics.OperationCode.Group; packet.Data = response; peer.Send(serializer.Serialize(packet), Reliability.ReliableOrder); debugger.Log($"Send join response : peer[{peer.Id}] join group[{response.groupId}]"); }
public async Task Handle(VerAckMessage message, IPeer sender) { sender.IsReady = true; if (_blockchain.LastBlockHeader.Index < sender.Version.CurrentBlockIndex) { _logger.LogInformation($"The peer has {sender.Version.CurrentBlockIndex + 1} blocks but the current number of block headers is {_blockchain.LastBlockHeader.Index + 1}."); await sender.Send(new GetBlockHeadersMessage(_blockchain.LastBlockHeader.Hash)); } }
void IStage.Update() { if (_Counter.Second > _TimeToSend) { _Counter.Reset(); var size = _Random.Next(_PackageSize); _Peer.Send(_CreateData(size), 0, size); } }
private static async Task SynchronizeBlocks(IReadOnlyCollection <UInt256> blockHashes, IPeer sender) { var batchesCount = blockHashes.Count / MaxBlocksCountToSync + (blockHashes.Count % MaxBlocksCountToSync != 0 ? 1 : 0); for (var i = 0; i < batchesCount; i++) { var blockHashesInBatch = blockHashes .Skip(i * MaxBlocksCountToSync) .Take(MaxBlocksCountToSync); await sender.Send(new GetDataMessage(InventoryType.Block, blockHashesInBatch)); } }
/// <inheritdoc /> public override async Task Handle(BlockHeadersMessage message, IPeer sender) { message.Payload.Headers.ForEach(a => a.Type = HeaderType.Header); await _blockHeaderPersister.Persist(message.Payload.Headers ?? new BlockHeader[0]); if (_blockchainContext.LastBlockHeader.Index < sender.Version.CurrentBlockIndex) { _logger.LogInformation( $"The peer has {sender.Version.CurrentBlockIndex + 1} blocks but the current number of block headers is {_blockchainContext.LastBlockHeader.Index + 1}."); await sender.Send(new GetBlockHeadersMessage(_blockchainContext.LastBlockHeader.Hash)); } }
public async Task Handle(VersionMessage message, IPeer sender) { if (_server.Nonce != message.Payload.Nonce) { throw new InvalidOperationException("The handshake failed."); } if (_server.Version > message.Payload.Version) { _logger.LogWarning("Downgraded to lower protocol version."); sender.DowngradeProtocol(message.Payload.Version); } await sender.Send <VerAckMessage>(); }
public async Task Handle(VersionMessage message, IPeer sender) { sender.Version = message.Payload; if (_server.Nonce == sender.Version.Nonce) { throw new InvalidOperationException($"The handshake is failed due to \"{nameof(_server.Nonce)}\" value equality."); } if (_server.ProtocolVersion > sender.Version.Version) { _logger.LogWarning("Downgraded to a lower protocol version."); sender.DowngradeProtocol(sender.Version.Version); } await sender.Send <VerAckMessage>(); }
/// <inheritdoc /> public override async Task Handle(GetBlocksMessage message, IPeer sender) { var hashStart = (message.Payload.HashStart ?? new UInt256[0]) .Where(h => h != null) .Distinct() .ToArray(); if (hashStart.Length == 0) { return; } var hashStop = message.Payload.HashStop; var blockHash = (await Task.WhenAll(hashStart.Select(GetBlockHeader))) .Where(bh => bh != null) .OrderBy(bh => bh.Index) .Select(bh => bh.Hash) .FirstOrDefault(); if (blockHash == null || blockHash == hashStop) { return; } var blockHashes = new List <UInt256>(); do { blockHash = await this._blockRepository.GetNextBlockHash(blockHash); if (blockHash == null || blockHash == hashStop) { break; } blockHashes.Add(blockHash); } while (blockHashes.Count < MaxBlocksCountToReturn); if (blockHashes.Count == 0) { return; } await sender.Send(new InventoryMessage(InventoryType.Block, blockHashes)); }
public async Task Handle(GetBlockHeadersMessage message, IPeer sender) { var hashStart = (message.Payload.HashStart ?? new UInt256[0]) .Where(h => h != null) .Distinct() .ToArray(); if (hashStart.Length == 0) { return; } var hashStop = message.Payload.HashStop; var blockHash = (await Task.WhenAll(hashStart.Select(GetBlockHeader))) .Where(bh => bh != null) .OrderBy(bh => bh.Index) .Select(bh => bh.Hash) .FirstOrDefault(); if (blockHash == null || blockHash == hashStop) { return; } var blockHeaders = new List <BlockHeader>(); do { blockHash = await _blockchain.GetNextBlockHash(blockHash); if (blockHash == null || blockHash == hashStop) { break; } blockHeaders.Add(await _blockchain.GetBlockHeader(blockHash)); } while (blockHeaders.Count < MaxBlockHeadersCountToReturn); if (blockHeaders.Count == 0) { return; } await sender.Send(new BlockHeadersMessage(blockHeaders)); }
/// <inheritdoc /> public override async Task Handle(VersionMessage message, IPeer sender) { sender.Version = message.Payload; if (_serverContext.Version.Nonce == sender.Version.Nonce) { throw new InvalidMessageException($"The handshake is failed due to \"{nameof(_serverContext.Version.Nonce)}\" value equality."); } // Change protocol? if (sender.ChangeProtocol(message.Payload)) { _logger?.LogWarning("Changed protocol."); } // Send Ack await sender.Send <VerAckMessage>(); }
public void Execute(IPeer peer, IPacket packet) { cPKTSay recvPacket = (cPKTSay)packet; cPKTSayResult sendPacket = new cPKTSayResult(); sendPacket.Message = recvPacket.Message; if (true == cChatRoomManager.Broadcast(peer.PeerId, recvPacket.Message)) { sendPacket.ResultCode = cPKTSayResult.eResultCode.SUCCEED; } else { sendPacket.ResultCode = cPKTSayResult.eResultCode.FAILURE; } peer.Send(sendPacket); }
public void Execute(IPeer peer, IPacket packet) { cPKTChatRoomChange recvPacket = (cPKTChatRoomChange)packet; cPKTChatRoomChangeResult resultPacket = new cPKTChatRoomChangeResult(); do { cChatPlayer chatPlayer = (cChatPlayer)peer; if (false == cChatRoomManager.ChangeChatRoom(chatPlayer.AccountId, recvPacket.NewChatRoomIndex)) { resultPacket.ResultCode = cPKTChatRoomChangeResult.eResultCode.CANNOT_CHANGE_CHAT_ROOM; break; } resultPacket.ResultCode = cPKTChatRoomChangeResult.eResultCode.SUCCEED; } while (false); peer.Send(resultPacket); }
private void _Write(TPackage[] packages) { try { _Buffer = _CreateBuffer(packages); var task = _Peer.Send(_Buffer, 0, _Buffer.Length); task.DoneEvent += _WriteCompletion; } catch (SystemException e) { var info = string.Format("PackageWriter Error Write {0}.", _Peer.Connected); Singleton <Log> .Instance.WriteInfo(info); if (ErrorEvent != null) { ErrorEvent(); } } }
/// <inheritdoc /> public override async Task Handle(GetAddrMessage message, IPeer sender) { var peers = this._serverContext.ConnectedPeers.Values .OrderBy(p => BitConverter.ToUInt32(Crypto.Default.GenerateRandomBytes(4), 0)) .Take(MaxCountToSend) .ToArray(); var networkAddressWithTimes = peers .Select(p => new NetworkAddressWithTime { EndPoint = p.EndPoint.ToIpEndPoint(), Services = p.Version.Services, Timestamp = p.Version.Timestamp } ) .ToArray(); await sender.Send ( new AddrMessage(networkAddressWithTimes) ); }
private void PeerConnected(object sender, IPeer peer) { try { if (_acl != null && !_acl.IsAllowed(peer)) { throw new UnauthorizedAccessException(); } this._connectedPeers.Add(peer); this.ListenForMessages(peer, this._messageListenerTokenSource.Token); // initiate handshake peer.Send(this.VersionMessage); } catch (Exception e) { this._logger.LogWarning($"Something went wrong with {peer}. Exception: {e}"); peer.Disconnect(); } }
public async Task Handle(GetAddrMessage message, IPeer sender) { var rand = new Random(Environment.TickCount); var peers = _server.ConnectedPeers .OrderBy(p => rand.Next()) .Take(MaxCountToSend) .ToArray(); var networkAddressWithTimes = peers .Select(p => new NetworkAddressWithTime { EndPoint = p.EndPoint.ToIpEndPoint(), Services = p.Version.Services, Timestamp = p.Version.Timestamp } ) .ToArray(); await sender.Send ( new AddrMessage(networkAddressWithTimes) ); }