internal static void Raise(this OnPeerConnected @event, object sender, PeerEventArgs e)
{
if (@event != null)
{
@event(sender, e);
}
}
private async Task AcceptPeers()
{
while (true)
{
Socket socket;
try
{
socket = await _listener.AcceptSocketAsync();
_logger.LogInformation($"\"{(socket.RemoteEndPoint as IPEndPoint)?.Address}\" is connected");
}
catch (ObjectDisposedException)
{
break;
}
catch (SocketException)
{
continue;
}
var peer = _peerFactory.CreateFrom(socket);
OnPeerConnected?.Invoke(this, peer);
}
}
void OnNewConnection(int connectionId)
{
var connection = AddConnection(connectionId);
connection.ConnectTask.TrySetResult(new object());
OnPeerConnected?.Invoke(connection);
}
public static void Raise(this OnPeerConnected @event, object sender, ChannelEventArgs e)
{
if (@event != null)
{
@event(sender, e);
}
}
/// <summary>
/// Processes all events appeared since last call
/// </summary>
public override void ProcessEvents()
{
while (peerConnectionAttemptMessages.TryDequeue(out ENetPeerConnectionAttemptMessage connection_attempt_message))
{
ENetPeer peer = new ENetPeer(Guid.NewGuid(), connection_attempt_message.Peer, this);
OnPeerConnectionAttempted?.Invoke(peer);
if (IsConnectionAllowed(peer))
{
peers.Add(peer.GUID.ToString(), peer);
peerIDToPeerLookup.Add(peer.Peer.ID, peer);
OnPeerConnected?.Invoke(peer);
}
else
{
connection_attempt_message.Peer.Disconnect((uint)EDisconnectionReason.Banned);
}
}
while (peerDisconnectionMessages.TryDequeue(out ENetPeerDisconnectionMessage disconnection_message))
{
RemovePeer(disconnection_message.Peer);
}
while (peerTimeOutMessages.TryDequeue(out ENetPeerTimeOutMessage time_out_message))
{
RemovePeer(time_out_message.Peer);
}
while (peerReceiveMessages.TryDequeue(out ENetPeerReceiveMessage receive_message))
{
if (peerIDToPeerLookup.ContainsKey(receive_message.Peer.ID))
{
OnPeerMessageReceived?.Invoke(peerIDToPeerLookup[receive_message.Peer.ID], receive_message.Message);
}
}
}
protected virtual NetworkConnection OnNewConnection(int connectionId)
{
var connection = AddConnection(connectionId);
if (connection.ConnectInternal())
{
OnPeerConnected?.Invoke(connection);
}
return(connection);
}
/// <summary>
/// Initializes the server.
/// Only use this if you've set a main channel with <see cref="UNetServer(IServerChannel)"/>
/// </summary>
/// <remarks>
/// May generate a <see cref="ServerInitializationException"/> if used incorrectly
/// </remarks>
public void Initialize()
{
if (_channelMgr.GetChannel <IServerChannel>(ch => ch is IServerChannel && ch.IsMainChannel) == null)
{
throw new ServerInitializationException("Attempt to initialize server without a main channel");
}
_channelMgr.GetChannel <IServerChannel>(ch => ch is IServerChannel && ch.IsMainChannel)
.Start();
_channelMgr.GetChannel <IServerChannel>(ch => ch is IServerChannel && ch.IsMainChannel)
.OnPeerConnected +=
(sender, e) => OnPeerConnected.Raise(sender, e);
}
/// <summary>
/// Adds a channel to this server
/// </summary>
/// <remarks>
/// May throw a <see cref="ChannelOperationException"/> if used incorrectly
/// </remarks>
/// <param name="channel">The channel to add</param>
/// <returns>Returns true if channel was added successfully</returns>
public bool AddChannel(IServerChannel channel)
{
if (!_channelMgr.AddChannel(channel))
{
return(false);
}
OnChannelCreated.Raise(this, new ChannelEventArgs(channel));
channel.HostServer = this;
channel.OnPeerConnected += (sender, e) => OnPeerConnected.Raise(this, e);
channel.PacketProcessor = _channelMgr.GetMainChannel().PacketProcessor;
return(true);
}
/// <summary>
/// Initializes the server.
/// Only use this if you haven't set a main channel with <see cref="UNetServer()"/>
/// </summary>
/// <param name="mainChannel">The server main channel to use</param>
public void Initialize(IServerChannel mainChannel)
{
if (_channelMgr.GetChannel <IServerChannel>(ch => ch.IsMainChannel) != null)
{
return;
}
mainChannel.IsMainChannel = true;
mainChannel.HostServer = this;
_channelMgr.UnsafeAddChannel(mainChannel);
_channelMgr.GetChannel <IServerChannel>(mainChannel.Id).Start();
_channelMgr.GetChannel <IServerChannel>(mainChannel.Id).OnPeerConnected +=
(sender, e) => OnPeerConnected.Raise(sender, e);
}
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 AddPeer(EndPoint address, Tracker tracker = null, bool withTracker = false)
{
if (!(Peers.Any(peer => peer.Address.Equals(address))) &&
!(address.Equals(CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true))))
{
var peer = new Peer(address, Peers, tracker);
Peers.Add(peer);
//перенаправляем события пира
peer.OnRequestBlocksMessage += (s, e) =>
{
OnRequestBlocksMessage?.Invoke(s, e);
};
peer.OnRequestTransactionsMessage += (s, e) =>
{
OnRequestTransactionsMessage?.Invoke(s, e);
};
peer.OnBlocksMessage += (s, e) =>
{
OnBlocksMessage?.Invoke(s, e);
};
peer.OnTransactionsMessage += (s, e) =>
{
OnTransactionsMessage?.Invoke(s, e);
};
peer.OnPeersMessage += (s, e) => OnPeersMessage(s, e);
peer.Connect(withTracker);
//вызов события подключения пира
Task.Run(() =>
{
System.Threading.Thread.Sleep(CommonHelpers.MessagesInterval * 5);
OnPeerConnected?.Invoke(this, new MessageEventArgs(new Message(), peer.Hash, peer.Address));
});
}
}
private void AcceptCallback(IAsyncResult res)
{
if (!IsActive)
{
return;
}
var newSock = ChannelSocket.EndAccept(res);
Peer.Peer newPeer;
if (IsMainChannel)
{
newPeer = new Peer.Peer(new SocketIdentity(Manager.GeneratePeerId(), SocketIdentity.GenerateGuid()), newSock, BufferSize, this);
newPeer.OnPeerDisconnected += (o, e2) =>
{
OnPeerDisconnected.Raise(o, new ChannelEventArgs(this, newPeer));
};
newPeer.Receive();
AcceptPeer(newPeer);
}
else
{
newPeer = new Peer.Peer(new SocketIdentity(Manager.GeneratePeerId()), newSock, BufferSize, this);
PendingConnections.Add(new PendingPeerConnection(newPeer.Identity.Guid, newPeer));
newPeer.OnPeerDisconnected += (o, e2) =>
{
OnPeerDisconnected.Raise(o, new ChannelEventArgs(this, newPeer));
};
newPeer.Receive();
newPeer.OnPeerRelocationRequest += (sender, e) =>
{
if (PendingConnections.FirstOrDefault(pc => pc.Guid == e.PeerGuid && !pc.IsCancelled) != null)
{
AcceptPeer(newPeer);
OnPeerConnected.Raise(this, new ChannelEventArgs(this, e.Peer));
lock (_lockObj)
PendingConnections.Remove(PendingConnections.First(pc => pc.Guid == e.PeerGuid));
}
};
}
ChannelSocket.BeginAccept(AcceptCallback, null);
}
private void Listener_PeerConnectedEvent(NetPeer peer)
{
int id = peer.Id + 1;
jitterBuffersByPeerId[id] = new JitterBuffer(settings.JitterBufferDelayFrames);
NetDataWriter writer = new NetDataWriter();
writer.Put((byte)PacketType.Join);
writer.Put(id);
writer.Put(StatefulWorld.Instance.Frame);
peer.Send(writer, DeliveryMethod.ReliableOrdered);
writer.Reset();
Remote.SynchronizeAll();
NetDebug.Log($"Peer index <b>{peer.Id}</b> connected. Assigned global ID {id}.", LogType.Connection);
OnPeerConnected?.Invoke(id);
}
/// <summary>
/// Processes all events
/// </summary>
public override void ProcessEvents()
{
while (localPeerConnectionAttemptMessages.TryDequeue(out LocalPeerConnectionAttemptMessage local_peer_connection_attempt_message))
{
IPeer peer = local_peer_connection_attempt_message.Peer;
OnPeerConnectionAttempted?.Invoke(peer);
if (IsConnectionAllowed(peer))
{
peers.Add(peer.GUID.ToString(), peer);
OnPeerConnected?.Invoke(peer);
}
else
{
local_peer_connection_attempt_message.Peer.Disconnect(EDisconnectionReason.Banned);
}
}
while (localPeerDisconnectionMessages.TryDequeue(out LocalPeerDisconnectionMessage local_peer_disconnection_message))
{
IPeer peer = local_peer_disconnection_message.Peer;
string key = peer.GUID.ToString();
if (peers.ContainsKey(key))
{
OnPeerDisconnected?.Invoke(peer);
peers.Remove(key);
}
foreach (KeyValuePair <string, ILocalPeer> peer_peer in peerPeerLookup)
{
if (peer.GUID == peer_peer.Value.GUID)
{
peerPeerLookup.Remove(peer_peer.Key);
break;
}
}
}
while (localPeerReceiveMessages.TryDequeue(out LocalPeerReceiveMessage local_peer_receive_message))
{
OnPeerMessageReceived?.Invoke(local_peer_receive_message.Peer, Compression.Decompress(local_peer_receive_message.Message, local_peer_receive_message.Index, local_peer_receive_message.Length));
}
}
public void OnConnected(OnPeerConnected onPeerConnected)
{
this.onPeerConnected = onPeerConnected;
}
