public void ReceiveDisconnectMessage(string guestId)
{
_log.LogInformation($"-> SignalRHost.{nameof(ReceiveDisconnectMessage)}");
_log.LogDebug($"{nameof(guestId)} {guestId}");
_log.LogDebug($"Local UserId: {PeerInfo.Message.PeerId}");
var success = Guid.TryParse(guestId, out Guid guestGuid);
if (!success ||
guestGuid == Guid.Empty)
{
_log.LogWarning($"GuestId is not a GUID");
return;
}
var existingGuest = ConnectedPeers.FirstOrDefault(g => g.PeerId == guestId);
if (existingGuest == null)
{
_log.LogWarning("No existing guest found");
return;
}
ConnectedPeers.Remove(existingGuest);
UpdateConnectedPeers(null);
RaiseUpdateEvent();
_log.LogInformation($"SignalRHost.{nameof(ReceiveDisconnectMessage)} ->");
}
private void OnConnectToPeerWithTrackerMessage(PacketHeader packetHeader, Connection connection, ConnectToPeerWithTrackerMessage incomingObject)
{
Peer peerToConnect = allPeers.FirstOrDefault(peer => peer.Address.Equals(incomingObject.RecieverAddress));
if (peerToConnect != null)
{
if (!ConnectedPeers.Contains(peerToConnect))
{
ConnectedPeers.Add(peerToConnect);
}
if (!peerToConnect.ConnectedPeers.Contains(this))
{
peerToConnect.ConnectedPeers.Add(this);
try
{
peerToConnect.Connection.SendObject(incomingObject.GetType().Name, incomingObject);
}
catch
{
peerToConnect.OnError();
}
}
}
//если трекер не нашел пир адресат то отправляем отправителю дисконнект адресата
else
{
var message = new PeerDisconnectMessage(incomingObject.SenderAddress);
Connection.SendObject(message.GetType().Name, message);
}
}
private void UpdateConnectedPeers(PeerMessage message)
{
if (message != null)
{
ConnectedPeers.Add(message);
}
NamedGuests = ConnectedPeers
.Where(g => !string.IsNullOrEmpty(g.CustomName) &&
g.CustomName != PeerMessage.AnonymousName &&
!g.IsHost).ToList();
AnonymousGuests = ConnectedPeers
.Count(g => (string.IsNullOrEmpty(g.CustomName) ||
g.CustomName == PeerMessage.AnonymousName) &&
!g.IsHost);
NamedHosts = ConnectedPeers
.Where(g => !string.IsNullOrEmpty(g.CustomName) &&
g.CustomName != PeerMessage.AnonymousName &&
g.IsHost).ToList();
AnonymousHosts = ConnectedPeers
.Count(g => (string.IsNullOrEmpty(g.CustomName) ||
g.CustomName == PeerMessage.AnonymousName) &&
g.IsHost);
RaiseUpdateEvent();
foreach (var guest in ConnectedPeers)
{
_log.LogDebug($"{guest.CustomName}");
_log.LogDebug($"{guest.DisplayName}");
}
}
private async void AcceptAsync()
{
while (true)
{
var client = await _uNetSock.AcceptTcpClientAsync();
var peer = new Peer(client, this, Settings);
//Subscribe to peer events
peer.OnPeerDisconnected += PeerDisconnect;
peer.OnPacketReceived += (o, e) => { if (OnPacketReceived != null)
{
OnPacketReceived(o, e);
}
};
peer.InternalOnPacketReceived += InternalOnPacketReceived;
peer.Processor.OnPacketSent += (o, e) => { if (OnPacketSent != null)
{
OnPacketSent(null, new PacketEventArgs(null, e.Packet, e.RawPacketSize));
}
};
ConnectedPeers.Add(peer);
if (_debug)
{
Debug.Print("Peer connected from: " + peer.RemoteEndPoint);
}
if (OnPeerConnected != null)
{
OnPeerConnected(null, new PeerConnectedEventArgs(peer));
}
}
}
/// <summary>
/// Check the new connection <br/>
/// If it is equal to the Nonce of local or any remote node, it'll return false, else we'll return true and update the Listener address of the connected remote node.
/// </summary>
/// <param name="actor">Remote node actor</param>
/// <param name="node">Remote node</param>
public bool AllowNewConnection(IActorRef actor, RemoteNode node)
{
if (node.Version.Magic != ProtocolSettings.Default.Magic)
{
return(false);
}
if (node.Version.Nonce == Nonce)
{
return(false);
}
// filter duplicate connections
foreach (var other in RemoteNodes.Values)
{
if (other != node && other.Remote.Address.Equals(node.Remote.Address) && other.Version?.Nonce == node.Version.Nonce)
{
return(false);
}
}
if (node.Remote.Port != node.ListenerTcpPort && node.ListenerTcpPort != 0)
{
ConnectedPeers.TryUpdate(actor, node.Listener, node.Remote);
}
return(true);
}
/// <summary>
/// Handle incoming packets related to connection setup
/// </summary>
/// <param name="message">The message to handle</param>
/// <returns>A PacketResponse indicating if the message was consumed</returns>
public PacketResponse HandlePacket(Message message)
{
switch (message.MessageType)
{
case MessageType.HeartbeatRequest:
var msg = new Message(MessageType.Heartbeat, message.Sender)
{
DataAsString = Dns.GetHostName()
};
Outbox.SendUnencryptedMessage(msg);
if (!ConnectedPeers.ContainsKey(message.Sender))
{
ConnectedPeers.Add(message.Sender, message.DataAsString);
}
return(PacketResponse.Accept);
case MessageType.Heartbeat:
if (!ConnectedPeers.ContainsKey(message.Sender))
{
ConnectedPeers.Add(message.Sender, message.DataAsString);
}
return(PacketResponse.Accept);
case MessageType.EncryptionPacket:
SecurityManager.GetInstance().SetKeysFromPacket(message.Data);
Inbox.GetInstance().UseEncryption = true;
ConnectionDone = true;
return(PacketResponse.AcceptAndFinish);
default:
return(PacketResponse.Decline);
}
}
public override void Shutdown()
{
// stop accepting new messages
ShutdownWorker();
Thread.Sleep(100);
if (WorkerThread != null)
{
WorkerThread.Abort();
}
WorkerThread = null;
lock (ConnectedPeers)
{
foreach (var p in ConnectedPeers)
{
p.Value.SocketConnection.Disconnect("shutdown");
p.Value.SocketConnection.Peer.FlushSendQueue();
p.Value.Handler.PeerDisconnected("Force Shutdown", p.Value);
}
ConnectedPeers.Clear();
}
base.Shutdown();
}
/// <summary>
/// Disconnects a peer from this channel
/// </summary>
/// <param name="id">The ID of the peer to disconnect</param>
public void DisconnectPeer(int id)
{
var peer = ConnectedPeers.First(p => p.Identity.Id == id);
peer.Disconnect();
lock (_lockObj)
ConnectedPeers.Remove(peer);
}
/// <summary>
/// Disconnects a peer from this channel
/// </summary>
/// <param name="pred">The predicate used to determine what peer to disconnect</param>
public void DisconnectPeer(Predicate <Peer.Peer> pred)
{
var peer = ConnectedPeers.First(new Func <Peer.Peer, bool>(pred));
peer.Disconnect();
lock (_lockObj)
ConnectedPeers.Remove(peer);
}
public void Send(IDataPacket data, int peerId)
{
var peer = ConnectedPeers.FirstOrDefault(p => p.Identity.Id == peerId);
if (peer == null)
{
throw new PeerNotFoundException();
}
peer.SendData(data, this, null);
}
internal void OperationSend(IDataPacket data, Guid peerGuid, Guid operationGuid)
{
var peer = ConnectedPeers.FirstOrDefault(p => p.Identity.Guid == peerGuid);
if (peer == null)
{
throw new PeerNotFoundException();
}
peer.SendData(data, this, new SocketOperationContext(operationGuid));
}
public void Send(IDataPacket data, Predicate <Peer.Peer> pred)
{
var peer = ConnectedPeers.FirstOrDefault(new Func <Peer.Peer, bool>(pred));
if (peer == null)
{
throw new PeerNotFoundException();
}
peer.SendData(data, this, null);
}
/// <summary>
/// Broadcast a packet to all currently connected peers
/// </summary>
/// <param name="packet">The packet to be broadcasted</param>
public void Broadcast(IPacket packet)
{
ConnectedPeers.ForEach(x =>
{
lock (_sendLock)
{
x.Processor.SendPacket(packet, x.NetStream).Wait();
}
});
}
/// <summary>
/// Sends a packet containing data to a specific peer
/// </summary>
/// <param name="packet">The packet to be sent</param>
/// <param name="targetPeer">A peer will be filtered from connected peers based on this predicate</param>
public void SendPacket(IPacket packet, Predicate <Peer> targetPeer)
{
var target = ConnectedPeers.FirstOrDefault(x => targetPeer(x));
if (target == null)
{
throw new Exception("No peer match for current predicate");
}
lock (_sendLock) target.Processor.SendPacket(packet, target.NetStream).Wait();
}
/// <summary>
/// Gets a hashcode of all statistics combined.
/// </summary>
/// <returns>A hashcode.</returns>
public override int GetHashCode()
{
// HashCode.Combine() is not available on all frameworks.
return
(PeersCount.GetHashCode() ^
DuplicatePeers.GetHashCode() ^
ConnectedPeers.GetHashCode() ^
TotalReceivedPackets.GetHashCode() ^
TotalReceivedData.GetHashCode() ^
TotalSentPackets.GetHashCode() ^
TotalSentData.GetHashCode());
}
private void PeerDisconnect(object sender, PeerEventArgs e)
{
if (OnPeerDisconnected != null)
{
OnPeerDisconnected(null, e);
}
ConnectedPeers.Remove(e.Peer);
if (_debug)
{
Debug.Print("Peer disconnected from: {0} with reason: {1}", e.Peer.RemoteEndPoint,
((PeerDisconnectedEventArgs)e).DisconnectReason);
}
}
/// <summary>
/// Check the new connection <br/>
/// If it is equal to the Nonce of local or any remote node, it'll return false, else we'll return true and update the Listener address of the connected remote node.
/// </summary>
/// <param name="actor">Remote node actor</param>
/// <param name="node">Remote node</param>
public bool AllowNewConnection(IActorRef actor, RemoteNode node)
{
if (node.Version.Magic != system.Settings.Magic) return false;
if (node.Version.Nonce == Nonce) return false;
// filter duplicate connections
foreach (var other in RemoteNodes.Values)
if (other != node && other.Remote.Address.Equals(node.Remote.Address) && other.Version?.Nonce == node.Version.Nonce)
return false;
if (node.Remote.Port != node.ListenerTcpPort && node.ListenerTcpPort != 0)
ConnectedPeers.TryUpdate(actor, node.Listener, node.Remote);
return true;
}
protected virtual void Dispose(bool disposing)
{
if (IsDisposed)
{
return;
}
if (disposing)
{
OnPeerConnected = null;
ConnectedPeers.ForEach(p => p.Disconnect());
IsActive = false;
ChannelSocket.Close();
}
IsDisposed = true;
}
private void AcceptPeer(Peer.Peer newPeer)
{
newPeer.OnPeerSynchronized +=
(sender, e) => OnPeerConnected.Raise(this, new ChannelEventArgs(this, e.Peer));
newPeer.OnPeerDisconnected +=
(sender, e) =>
{
e.Peer.Dispose();
lock (_lockObj)
ConnectedPeers.Remove(e.Peer);
};
newPeer.OnRawPacketReceived += RawPacketReceived;
newPeer.OnSequenceFragmentReceived += (sender, e) => OnSequenceFragmentReceived.Raise(sender, e);
lock (_lockObj)
ConnectedPeers.Add(newPeer);
}
private void OnToPeerMessage(PacketHeader packetHeader, Connection connection, ToPeerMessage incomingObject)
{
NetworkComms.Logger.Warn("Message: " + incomingObject.Message.Type.ToString());
if (Address.Equals(incomingObject.SenderAddress))
{
Peer reciever = ConnectedPeers.FirstOrDefault(peer => peer.Address.Equals(incomingObject.RecieverAddress));
try
{
if (reciever != null && reciever.ConnectedPeers.Contains(this))
{
reciever.Connection.SendObject(incomingObject.GetType().Name, incomingObject);
}
}
catch
{
reciever.OnError();
}
}
}
public async Task ReceiveGuestMessage(string json)
{
_log.LogInformation($"-> SignalRHost.{nameof(ReceiveGuestMessage)}");
//_log.LogDebug(json);
var messagePeer = JsonConvert.DeserializeObject <PeerMessage>(json);
if (messagePeer == null ||
string.IsNullOrEmpty(messagePeer.PeerId))
{
_log.LogWarning($"No PeerId found");
return;
}
_log.LogDebug($"PeerId: {messagePeer.PeerId}");
var success = Guid.TryParse(messagePeer.PeerId, out Guid peerId);
if (!success ||
peerId == Guid.Empty)
{
_log.LogWarning($"PeerId is not a GUID");
return;
}
if (messagePeer.PeerId == PeerInfo.Message.PeerId)
{
_log.LogTrace($"Self announce received");
return;
}
var existingPeer = ConnectedPeers.FirstOrDefault(g => g.PeerId == messagePeer.PeerId);
if (existingPeer == null)
{
_log.LogWarning("No existing guest found");
UpdateConnectedPeers(messagePeer);
}
else
{
_log.LogDebug($"Existing peer found: Old name {existingPeer.DisplayName}");
existingPeer.CustomName = messagePeer.CustomName;
existingPeer.IsHost = messagePeer.IsHost;
UpdateConnectedPeers(null);
_log.LogDebug($"Existing guest found: New name {existingPeer.DisplayName}");
}
// Refresh the clocks and the message (only when a guest registers)
_log.LogDebug($"messagePeer.IsHost {messagePeer.IsHost}");
if (!messagePeer.IsHost)
{
if (IsAnyClockRunning)
{
await StartAllClocks(false);
}
await SendMessage(CurrentMessage.Value);
}
RaiseUpdateEvent();
_log.LogInformation($"SignalRHost.{nameof(ReceiveGuestMessage)} ->");
}
/// <summary>
/// Broadcasts a message to all peers in this channel
/// </summary>
/// <param name="data">The packet to broadcast</param>
public void Broadcast(IDataPacket data)
{
ConnectedPeers.ForEach(cp => cp.SendData(data, this, null));
}
/// <summary>
/// Disconnects a peer from this channel
/// </summary>
/// <param name="peer">The peer to disconnect</param>
public void DisconnectPeer(Peer.Peer peer)
{
peer.Disconnect();
lock (_lockObj)
ConnectedPeers.Remove(peer);
}
