/// <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(); }