/// <summary> /// Creates the handler pipeline. After this, it passes the user-set pipeline /// filter where the handlers can be modified. /// </summary> /// <param name="isTcp"></param> private Pipeline GetPipeline(bool isTcp) { var timeoutFactory = new TimeoutFactory(null, ChannelServerConfiguration.IdleTcpSeconds, _peerStatusListeners, "Server"); var pipeline = new Pipeline(); if (isTcp) { pipeline.AddLast("dropconnection", _tcpDropConnectionInboundHandler); pipeline.AddLast("timeout0", timeoutFactory.CreateIdleStateHandlerTomP2P()); pipeline.AddLast("timeout1", timeoutFactory.CreateTimeHandler()); pipeline.AddLast("decoder", _tcpDecoderHandler); } else { // no need for a timeout handler, since whole packet arrives or nothing // different from TCP where the stream can be closed by the remote peer // in the middle of the transmission pipeline.AddLast("dropconnection", _udpDropConnectionInboundHandler); pipeline.AddLast("decoder", _udpDecoderHandler); } pipeline.AddLast("encoder", _encoderHandler); pipeline.AddLast("dispatcher", _dispatcher); var filteredPipeline = ChannelServerConfiguration.PipelineFilter.Filter(pipeline, isTcp, false); return(filteredPipeline); }
private ITcpClientChannel SendTcpCreateChannel(IPEndPoint recipient, ChannelCreator channelCreator, PeerConnection peerConnection, IChannelHandler handler, TimeoutFactory timeoutHandler, int connectTimeoutMillis) { // create pipeline var handlers = new Dictionary <string, IChannelHandler>(); if (timeoutHandler != null) { handlers.Add("timeout0", timeoutHandler.CreateIdleStateHandlerTomP2P()); handlers.Add("timeout1", timeoutHandler.CreateTimeHandler()); } handlers.Add("decoder", new TomP2PCumulationTcp(ChannelClientConfiguration.SignatureFactory)); handlers.Add("encoder", new TomP2POutbound(false, ChannelClientConfiguration.SignatureFactory)); if (peerConnection != null) { // we expect responses on this connection handlers.Add("dispatcher", _dispatcher); } if (timeoutHandler != null) { handlers.Add("handler", handler); } HeartBeat heartBeat = null; if (peerConnection != null) { heartBeat = new HeartBeat(peerConnection.HeartBeatMillis, PingBuilderFactory); handlers.Add("heartbeat", heartBeat); } var channel = channelCreator.CreateTcp(recipient, connectTimeoutMillis, handlers); if (peerConnection != null && channel != null) { peerConnection.SetChannel(channel); heartBeat.SetPeerConnection(peerConnection); } return(channel); }
/// <summary> /// Sends a message via UDP. /// </summary> /// <param name="handler">The handler to deal with the response message.</param> /// <param name="tcsResponse">The TCS for the response message. (FutureResponse equivalent.)</param> /// <param name="message">The message to send.</param> /// <param name="channelCreator">The channel creator for the UDP channel.</param> /// <param name="idleUdpSeconds">The idle time of a message until fail.</param> /// <param name="broadcast">True, if the message is to be sent via layer 2 broadcast.</param> /// <returns>The response message or null, if it is fire-and-forget or a failure occurred.</returns> public async Task SendUdpAsync(IInboundHandler handler, TaskCompletionSource <Message.Message> tcsResponse, Message.Message message, ChannelCreator channelCreator, int idleUdpSeconds, bool broadcast) { // no need to continue if already finished if (tcsResponse.Task.IsCompleted) { return; } RemovePeerIfFailed(tcsResponse, message); bool isFireAndForget = handler == null; // relay options if (message.Sender.IsRelayed) { message.SetPeerSocketAddresses(message.Sender.PeerSocketAddresses); IList <PeerSocketAddress> relayAddresses = new List <PeerSocketAddress>(message.Recipient.PeerSocketAddresses); Logger.Debug("Send neighbor request to random relay peer {0}.", relayAddresses); if (relayAddresses.Count > 0) { var relayAddress = relayAddresses[_random.NextInt(relayAddresses.Count)]; message.SetRecipientRelay(message.Recipient .ChangePeerSocketAddress(relayAddress) .ChangeIsRelayed(true)); } else { const string msg = "Peer is relayed, but no relay is given."; Logger.Error(msg); tcsResponse.SetException(new TaskFailedException(msg)); return; } } // check for invalid UDP connection to unreachable peers if (message.Recipient.IsRelayed && message.Command != Rpc.Rpc.Commands.Neighbor.GetNr() && message.Command != Rpc.Rpc.Commands.Ping.GetNr()) { string msg = String.Format( "Tried to send a UDP message to unreachable peers. Only TCP messages can be sent to unreachable peers: {0}.", message); Logger.Warn(msg); tcsResponse.SetException(new TaskFailedException(msg)); return; } // pipeline handler setup TimeoutFactory timeoutFactory = CreateTimeoutHandler(tcsResponse, idleUdpSeconds, isFireAndForget); var handlers = new Dictionary <string, IChannelHandler>(); if (!isFireAndForget) { handlers.Add("timeout0", timeoutFactory.CreateIdleStateHandlerTomP2P()); handlers.Add("timeout1", timeoutFactory.CreateTimeHandler()); } handlers.Add("decoder", new TomP2PSinglePacketUdp(ChannelClientConfiguration.SignatureFactory)); handlers.Add("encoder", new TomP2POutbound(false, ChannelClientConfiguration.SignatureFactory)); if (!isFireAndForget) { handlers.Add("handler", handler); } // create UDP channel MyUdpClient udpClient = null; try { udpClient = channelCreator.CreateUdp(broadcast, handlers); } catch (Exception ex) { string msg = "Channel creation failed. " + ex; Logger.Debug(msg); tcsResponse.SetException(ex); // may have been closed by the other side // or it may have been canceled from this side } // "afterConnect" // check if channel could be created (due to shutdown) if (udpClient == null) { const string msg = "Could not create a UDP socket. (Due to shutdown.)"; Logger.Warn(msg); tcsResponse.SetException(new TaskFailedException(msg)); return; } Logger.Debug("About to connect to {0} with channel {1}, ff = {2}.", message.Recipient, udpClient, isFireAndForget); // send request message // processes client-side outbound pipeline // (await for possible exception re-throw, does not block) await udpClient.SendMessageAsync(message); // if not fire-and-forget, receive response if (isFireAndForget) { Logger.Debug("Fire and forget message {0} sent. Close channel {1} now.", message, udpClient); tcsResponse.SetResult(null); // set FF result } else { // receive response message // processes client-side inbound pipeline await udpClient.ReceiveMessageAsync(); } udpClient.Close(); }
private ITcpClientChannel SendTcpCreateChannel(IPEndPoint recipient, ChannelCreator channelCreator, PeerConnection peerConnection, IChannelHandler handler, TimeoutFactory timeoutHandler, int connectTimeoutMillis) { // create pipeline var handlers = new Dictionary<string, IChannelHandler>(); if (timeoutHandler != null) { handlers.Add("timeout0", timeoutHandler.CreateIdleStateHandlerTomP2P()); handlers.Add("timeout1", timeoutHandler.CreateTimeHandler()); } handlers.Add("decoder", new TomP2PCumulationTcp(ChannelClientConfiguration.SignatureFactory)); handlers.Add("encoder", new TomP2POutbound(false, ChannelClientConfiguration.SignatureFactory)); if (peerConnection != null) { // we expect responses on this connection handlers.Add("dispatcher", _dispatcher); } if (timeoutHandler != null) { handlers.Add("handler", handler); } HeartBeat heartBeat = null; if (peerConnection != null) { heartBeat = new HeartBeat(peerConnection.HeartBeatMillis, PingBuilderFactory); handlers.Add("heartbeat", heartBeat); } var channel = channelCreator.CreateTcp(recipient, connectTimeoutMillis, handlers); if (peerConnection != null && channel != null) { peerConnection.SetChannel(channel); heartBeat.SetPeerConnection(peerConnection); } return channel; }