public void Response(Message.Message responseMessage)
{
if (responseMessage.Sender.IsRelayed)
{
responseMessage.SetPeerSocketAddresses(responseMessage.Sender.PeerSocketAddresses);
}
_dispatcher.Respond(_ctx, responseMessage);
}
/// <summary>
/// Sends a message via TCP.
/// </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 TCP channel.</param>
/// <param name="idleTcpSeconds">The idle time until message fail.</param>
/// <param name="connectTimeoutMillis">The idle time for the connection setup.</param>
/// <param name="peerConnection"></param>
/// <returns></returns>
public async Task SendTcpAsync(IInboundHandler handler, TaskCompletionSource <Message.Message> tcsResponse,
Message.Message message, ChannelCreator channelCreator, int idleTcpSeconds, int connectTimeoutMillis,
PeerConnection peerConnection)
{
// no need to continue if already finished
if (tcsResponse.Task.IsCompleted)
{
return;
}
RemovePeerIfFailed(tcsResponse, message);
bool isFireAndForget = handler == null;
// we need to set the neighbors if we use relays
if (message.Sender.IsRelayed && message.Sender.PeerSocketAddresses.Count != 0)
{
message.SetPeerSocketAddresses(message.Sender.PeerSocketAddresses);
}
if (peerConnection != null && peerConnection.Channel != null && peerConnection.Channel.IsOpen)
{
var channel = SendTcpPeerConnection(peerConnection, handler, channelCreator, tcsResponse);
await AfterConnectAsync(tcsResponse, message, channel, isFireAndForget);
}
else if (channelCreator != null)
{
var timeoutHandler = CreateTimeoutHandler(tcsResponse, idleTcpSeconds, handler == null);
// check relay
if (message.Recipient.IsRelayed)
{
// check if reverse connection is possible
if (!message.Sender.IsRelayed)
{
await HandleRconAsync(handler, tcsResponse, message, channelCreator, connectTimeoutMillis, peerConnection,
timeoutHandler);
}
else
{
await HandleRelayAsync(handler, tcsResponse, message, channelCreator, idleTcpSeconds, connectTimeoutMillis,
peerConnection, timeoutHandler);
}
}
// normal connection
else
{
await ConnectAndSendAsync(handler, tcsResponse, channelCreator, connectTimeoutMillis, peerConnection,
timeoutHandler, message);
}
}
}
/// <summary>
/// // TODO document
/// </summary>
/// <param name="handler"></param>
/// <param name="tcsResponse"></param>
/// <param name="message"></param>
/// <param name="channelCreator"></param>
/// <param name="idleTcpSeconds"></param>
/// <param name="connectTimeoutMillis"></param>
/// <param name="peerConnection"></param>
/// <param name="timeoutHandler"></param>
private async Task HandleRelayAsync(IInboundHandler handler, TaskCompletionSource <Message.Message> tcsResponse,
Message.Message message, ChannelCreator channelCreator, int idleTcpSeconds, int connectTimeoutMillis,
PeerConnection peerConnection, TimeoutFactory timeoutHandler)
{
var taskPingDone = PingFirst(message.Recipient.PeerSocketAddresses);
await taskPingDone;
if (!taskPingDone.IsFaulted)
{
var recipient = PeerSocketAddress.CreateSocketTcp(taskPingDone.Result);
var channel = SendTcpCreateChannel(recipient, channelCreator, peerConnection, handler,
timeoutHandler, connectTimeoutMillis);
await AfterConnectAsync(tcsResponse, message, channel, handler == null);
// TODO add this before AfterConnect?
var taskResponse = tcsResponse.Task;
await taskResponse;
if (taskResponse.IsFaulted)
{
if (taskResponse.Result != null &&
taskResponse.Result.Type != Message.Message.MessageType.User1)
{
// "clearInactivePeerSocketAddress"
var tmp = new List <PeerSocketAddress>();
foreach (var psa in message.Recipient.PeerSocketAddresses)
{
if (psa != null)
{
if (!psa.Equals(taskPingDone.Result))
{
tmp.Add(psa);
}
}
}
message.SetPeerSocketAddresses(tmp);
await SendTcpAsync(handler, tcsResponse, message, channelCreator, idleTcpSeconds,
connectTimeoutMillis, peerConnection);
}
}
}
else
{
// .NET-specific:
tcsResponse.SetException(new TaskFailedException("No relay could be contacted. <-> " + taskPingDone.Exception));
}
}
/// <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();
}