/// <summary>
/// Gets a new transfer connection using the details in the specified <paramref name="connectToPeerResponse"/>,
/// pierces the remote peer's firewall, and retrieves the remote token.
/// </summary>
/// <param name="connectToPeerResponse">The response that solicited the connection.</param>
/// <returns>The operation context, including the new connection and the associated remote token.</returns>
public async Task <(IConnection Connection, int RemoteToken)> GetTransferConnectionAsync(ConnectToPeerResponse connectToPeerResponse)
{
Diagnostic.Debug($"Attempting inbound indirect transfer connection to {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for token {connectToPeerResponse.Token}");
var connection = ConnectionFactory.GetTransferConnection(
connectToPeerResponse.IPEndPoint,
SoulseekClient.Options.TransferConnectionOptions);
connection.Type = ConnectionTypes.Inbound | ConnectionTypes.Indirect;
connection.Disconnected += (sender, e) => Diagnostic.Debug($"Transfer connection to {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for token {connectToPeerResponse.Token} disconnected. (type: {connection.Type}, id: {connection.Id})");
int remoteToken;
try
{
await connection.ConnectAsync().ConfigureAwait(false);
var request = new PierceFirewall(connectToPeerResponse.Token);
await connection.WriteAsync(request.ToByteArray()).ConfigureAwait(false);
var remoteTokenBytes = await connection.ReadAsync(4).ConfigureAwait(false);
remoteToken = BitConverter.ToInt32(remoteTokenBytes, 0);
}
catch (Exception ex)
{
var msg = $"Failed to establish an inbound indirect transfer connection to {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}): {ex.Message}";
Diagnostic.Debug(msg);
connection.Dispose();
throw new ConnectionException(msg, ex);
}
Diagnostic.Debug($"Transfer connection to {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for token {connectToPeerResponse.Token} established. (type: {connection.Type}, id: {connection.Id})");
return(connection, remoteToken);
}
/// <summary>
/// Returns an existing, or gets a new connection using the details in the specified
/// <paramref name="connectToPeerResponse"/> and pierces the remote peer's firewall.
/// </summary>
/// <remarks>
/// This method will be invoked from <see cref="Messaging.Handlers.ServerMessageHandler"/> upon receipt of an
/// unsolicited <see cref="ConnectToPeerResponse"/> of type 'P' only. This connection should only be initiated if
/// there is no existing connection; superseding should be avoided if possible.
/// </remarks>
/// <param name="connectToPeerResponse">The response that solicited the connection.</param>
/// <returns>The operation context, including the new or updated connection.</returns>
public async Task <IMessageConnection> GetOrAddMessageConnectionAsync(ConnectToPeerResponse connectToPeerResponse)
{
bool cached = true;
var r = connectToPeerResponse;
try
{
var connection = await MessageConnectionDictionary.GetOrAdd(
r.Username,
key => new Lazy <Task <IMessageConnection> >(() => GetConnection())).Value.ConfigureAwait(false);
if (cached)
{
Diagnostic.Debug($"Retrieved cached message connection to {r.Username} ({r.IPEndPoint}) (type: {connection.Type}, id: {connection.Id})");
}
return(connection);
}
catch (Exception ex)
{
var msg = $"Failed to establish an inbound indirect message connection to {r.Username} ({r.IPEndPoint}): {ex.Message}";
Diagnostic.Debug(msg);
Diagnostic.Debug($"Purging message connection cache of failed connection to {r.Username} ({r.IPEndPoint}).");
MessageConnectionDictionary.TryRemove(r.Username, out _);
throw new ConnectionException(msg, ex);
}
async Task <IMessageConnection> GetConnection()
{
cached = false;
Diagnostic.Debug($"Attempting inbound indirect message connection to {r.Username} ({r.IPEndPoint}) for token {r.Token}");
var connection = ConnectionFactory.GetMessageConnection(
r.Username,
r.IPEndPoint,
SoulseekClient.Options.PeerConnectionOptions);
connection.Type = ConnectionTypes.Inbound | ConnectionTypes.Indirect;
connection.MessageRead += SoulseekClient.PeerMessageHandler.HandleMessageRead;
connection.MessageReceived += SoulseekClient.PeerMessageHandler.HandleMessageReceived;
connection.MessageWritten += SoulseekClient.PeerMessageHandler.HandleMessageWritten;
connection.Disconnected += MessageConnection_Disconnected;
using (var cts = new CancellationTokenSource())
{
// add a record to the pending dictionary so we can tell whether the following code is waiting
PendingInboundIndirectConnectionDictionary.AddOrUpdate(r.Username, cts, (username, existingCts) => cts);
try
{
await connection.ConnectAsync(cts.Token).ConfigureAwait(false);
var request = new PierceFirewall(r.Token);
await connection.WriteAsync(request.ToByteArray(), cts.Token).ConfigureAwait(false);
}
catch
{
connection.Dispose();
throw;
}
finally
{
// let everyone know this code is done executing and that .Value of the containing cache is safe to await with no delay.
PendingInboundIndirectConnectionDictionary.TryRemove(r.Username, out _);
}
}
Diagnostic.Debug($"Message connection to {r.Username} ({r.IPEndPoint}) established. (type: {connection.Type}, id: {connection.Id})");
return(connection);
}
}
/// <summary>
/// Adds a new message connection from an incoming connection.
/// </summary>
/// <remarks>
/// This method will be invoked from <see cref="ListenerHandler"/> upon receipt of an incoming unsolicited message
/// only. Because this connection is fully established by the time it is passed to this method, it must supersede any
/// cached connection, as it will be the most recently established connection as tracked by the remote user.
/// </remarks>
/// <param name="username">The username of the user from which the connection originated.</param>
/// <param name="incomingConnection">The the accepted connection.</param>
/// <returns>The operation context.</returns>
public async Task AddMessageConnectionAsync(string username, IConnection incomingConnection)
{
var c = incomingConnection;
try
{
await MessageConnectionDictionary.AddOrUpdate(
username,
new Lazy <Task <IMessageConnection> >(() => GetConnection()),
(key, cachedConnectionRecord) => new Lazy <Task <IMessageConnection> >(() => GetConnection(cachedConnectionRecord))).Value.ConfigureAwait(false);
}
catch (Exception ex)
{
var msg = $"Failed to establish an inbound message connection to {username} ({c.IPEndPoint}): {ex.Message}";
Diagnostic.Debug($"{msg} (type: {c.Type}, id: {c.Id})");
Diagnostic.Debug($"Purging message connection cache of failed connection to {username} ({c.IPEndPoint}).");
MessageConnectionDictionary.TryRemove(username, out _);
throw new ConnectionException(msg, ex);
}
async Task <IMessageConnection> GetConnection(Lazy <Task <IMessageConnection> > cachedConnectionRecord = null)
{
Diagnostic.Debug($"Inbound message connection to {username} ({c.IPEndPoint}) accepted. (type: {c.Type}, id: {c.Id})");
var connection = ConnectionFactory.GetMessageConnection(
username,
c.IPEndPoint,
SoulseekClient.Options.PeerConnectionOptions,
c.HandoffTcpClient());
connection.Type = ConnectionTypes.Inbound | ConnectionTypes.Direct;
connection.MessageRead += SoulseekClient.PeerMessageHandler.HandleMessageRead;
connection.MessageWritten += SoulseekClient.PeerMessageHandler.HandleMessageWritten;
connection.Disconnected += MessageConnection_Disconnected;
Diagnostic.Debug($"Inbound message connection to {username} ({connection.IPEndPoint}) handed off. (old: {c.Id}, new: {connection.Id})");
if (cachedConnectionRecord != null)
{
// because the cache is Lazy<>, the cached entry may be either a connected or pending connection.
// if we try to reference .Value before the cached function is dispositioned we'll get stuck waiting for it,
// which will prevent this code from superseding the connection until the pending connection times out.
// to get around this the pending connection dictionary was added, allowing us to tell if the connection is still pending.
// if so, we can just cancel the token and move on.
if (PendingInboundIndirectConnectionDictionary.TryGetValue(username, out var pendingCts))
{
Diagnostic.Debug($"Cancelling pending inbound indirect message connection to {username}");
pendingCts.Cancel();
}
else
{
// if there's no entry in the pending connection dictionary, the Lazy<> function has completed executing and we know that
// awaiting .Value will return immediately, allowing us to tear down the disconnected event handler.
try
{
var cachedConnection = await cachedConnectionRecord.Value.ConfigureAwait(false);
cachedConnection.Disconnected -= MessageConnection_Disconnected;
Diagnostic.Debug($"Superseding cached message connection to {username} ({cachedConnection.IPEndPoint}) (old: {cachedConnection.Id}, new: {connection.Id}");
}
catch
{
// noop
}
}
}
connection.StartReadingContinuously();
Diagnostic.Debug($"Message connection to {username} ({connection.IPEndPoint}) established. (type: {connection.Type}, id: {connection.Id})");
return(connection);
}
}