public void Add(IPeer peer)
{
lock(this)
{
if (!_container.Contains(peer) && !peer.Equals(Peer.Self))
{
var lease = RemotingServices.GetLifetimeService((MarshalByRefObject) peer) as ILease;
if (lease != null) lease.Register(new SearchEngineSponsor());
_container.Add(peer);
try
{
foreach (var peer1 in peer.PeerContainer.GetAvailablePeers())
{
Add(peer1);
}
}
catch(RemotingException)
{
_container.Remove(peer);
}
catch (WebException)
{
_container.Remove(peer);
}
}
}
}
/// <summary>
/// Create a path to queue for the given <paramref name="peer"/> and <paramref name="messageQueuedTime"/>.
/// </summary>
/// <param name="peer">The peer to build the path for.</param>
/// <param name="messageQueuedTime">The message file time to build a path for.</param>
/// <returns>A path to queue for the given <paramref name="peer"/> and <paramref name="messageQueuedTime"/>.</returns>
public static string MessageLocation(IPeer peer, DateTime messageQueuedTime)
{
var messageLocation = string.Format(
CultureInfo.InvariantCulture,
"/{0}/queue/{1}",
peer.EscapePeerAddress(),
messageQueuedTime.ToFileTimeUtc());
return messageLocation;
}
private void OnRegisteredPeerDisconnect(IPeer peer)
{
var peerSpawners = peer.GetProperty((int)MstPeerPropertyCodes.RegisteredSpawners) as Dictionary <int, RegisteredSpawner>;
if (peerSpawners == null)
{
return;
}
// Create a copy so that we can iterate safely
var registeredSpawners = peerSpawners.Values.ToList();
foreach (var registeredSpawner in registeredSpawners)
{
DestroySpawner(registeredSpawner);
}
}
private void OnRegisteredPeerDisconnect(IPeer peer)
{
var peerRooms = peer.GetProperty((int)MsfPropCodes.RegisteredRooms) as Dictionary <int, RegisteredRoom>;
if (peerRooms == null)
{
return;
}
// Create a copy so that we can iterate safely
var registeredRooms = peerRooms.Values.ToList();
foreach (var registeredRoom in registeredRooms)
{
DestroyRoom(registeredRoom);
}
}
private void HandleUnsub(Frame frame, IPeer source)
{
var len = Util.ExtractMultiByte(frame.payload, 0);
if (!len.success)
{
// something bad happened.
}
var buff = new byte[len.value];
Array.Copy(frame.payload, (int)len.numBytesUsed, buff, 0, (int)len.value);
var channelName = Encoding.UTF8.GetString(buff);
subMan.Unsubscribe(source, channelName);
source.SendUnsubReply(channelName);
}
/// <summary>
/// Callback for when a Peer fires a <see cref="IPeer.PeerDisconnected"/> event. It unsubscribes
/// the manager from the events and removes it from the list.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ProcessClientDisconnection(object sender, EventArgs e)
{
if (sender != null && e is PeerDisconnectedArgs args && args.Peer != null)
{
IPeer peer = args.Peer;
peer.MessageReceived -= HandleNewMessage;
peer.PeerDisconnected -= ProcessClientDisconnection;
_peers.Remove(args.Peer);
lock (_syncLock)
{
SyncNext();
}
}
}
public void Poll()
{
PacketEvent[] events = eventPool.DequeueAll();
isPolling = true;
for (int i = 0; i < events.Length; i++)
{
IPeer peer = events[i].GetPeer();
object data = events[i].GetData();
Reliability reliability = events[i].GetReliability();
OnGroupReceiveEvent.Invoke(peer, data, reliability); // delegate method
}
isPolling = false;
if (isClosed)
{
CloseSafely();
}
}
protected void Page_Load(object sender, EventArgs e)
{
IServerResponse res = ServerResponseBase.GetServerResponseInstance();
try
{
IPeerRequest rq = PeerRequestBase.GetRequestInstance(Request.RawUrl);
Trace.Write("Request Object = " + rq);
IPeer peer = PeerBase.GetPeer();
peer.IP = (string.IsNullOrEmpty(rq.IP)) ? Request.UserHostAddress : rq.IP;
peer.Port = rq.Port;
peer.PeerID = rq.PeerID;
IPeerPoolManager manager = PeerPoolManagerBase.GetPeerPoolManager();
IPeerPool pool = manager.GetPeerPoolByInfoHash(rq.InfoHash);
pool.AddPeer(peer);
res.Interval = Convert.ToInt32(ConfigurationManager.AppSettings["Interval"]);
res.MinInterval = Convert.ToInt32(ConfigurationManager.AppSettings["MinInterval"]);
foreach (IPeer p in pool.GetPeerList())
{
if (p.IP == peer.IP && p.Port == peer.Port)
{
continue; // skip the request peer itself
}
res.Peers.Add(p);
}
Response.Clear();
byte[] binRes = res.GetBinaryResponse();
Trace.Write("binRes=" + HexEncoding.ToString(binRes));
Response.BinaryWrite(binRes);
}
catch (Exception Ex)
{
Trace.Write("ERROR: " + Ex);
res.FailureReason = Ex.ToString();
Response.Clear();
Response.Write(res);
}
Response.End();
}
public override IList <BlockInfo> PickPiece(IPeer peer, BitField available, IReadOnlyList <IPeer> otherPeers, int count, int startIndex, int endIndex)
{
// Fast Path - the peer has nothing to offer
if (available.AllFalse)
{
return(null);
}
// Rebuild if any file changed priority
if (ShouldRebuildSelectors())
{
BuildSelectors();
}
// Fast Path - As 'files' has been sorted highest priority first, all files
// must be set to DoNotDownload if this is true.
if (files[0].Priority == Priority.DoNotDownload)
{
return(null);
}
// Fast Path - If it's a single file, or if all the priorities are the same,
// then we can just pick normally. No prioritisation is needed.
if (files.Count == 1 || files.TrueForAll(AllSamePriority))
{
return(base.PickPiece(peer, available, otherPeers, count, startIndex, endIndex));
}
// Start with the highest priority and work our way down.
for (int i = 0; i < prioritised.Count; i++)
{
temp.From(prioritised[i]).And(available);
if (!temp.AllFalse)
{
IList <BlockInfo> result = base.PickPiece(peer, temp, otherPeers, count, startIndex, endIndex);
if (result != null)
{
return(result);
}
}
}
// None of the pieces from files marked as downloadable were available.
return(null);
}
private void Connected(IPeer peer)
{
// Listen to messages
peer.MessageReceived += OnMessageReceived;
// Save the peer
_connectedPeers[peer.Id] = peer;
// Create the security extension
var extension = peer.AddExtension(new PeerSecurityExtension());
// Set default permission level
extension.PermissionLevel = 0;
_logger.Info($"New Peer connected. ID: {peer.Id}");
// Invoke the event
PeerConnected?.Invoke(peer);
}
public void Invoke(string methodId, IPeer peer, Closure closure, params object[] objects)
{
if (string.IsNullOrEmpty(methodId))
{
throw new ArgumentException(nameof(methodId));
}
if (peer == null)
{
throw new ArgumentNullException(nameof(peer));
}
ResponseCallback responseCallback = (rm, sd) => {
closure?.Call(rm, sd);
};
Invoke(methodId, peer, responseCallback, objects);
}
public static PeerInfo FromNetworkPeer(IPeer peer)
{
return(new PeerInfo
{
IpAddress = peer.RemoteEndpoint.ToString(),
Pubkey = peer.Info.Pubkey,
LastKnownLibHeight = peer.LastKnownLibHeight,
ProtocolVersion = peer.Info.ProtocolVersion,
ConnectionTime = peer.Info.ConnectionTime.Seconds,
ConnectionStatus = peer.ConnectionStatus,
Inbound = peer.Info.IsInbound,
SyncState = peer.SyncState,
BufferedAnnouncementsCount = peer.BufferedAnnouncementsCount,
BufferedBlocksCount = peer.BufferedBlocksCount,
BufferedTransactionsCount = peer.BufferedTransactionsCount,
RequestMetrics = peer.GetRequestMetrics()?.Values.SelectMany(kvp => kvp).ToList()
});
}
private void OnUserDisconnect(IPeer peer)
{
var extension = peer.GetExtension <IUserExtension>();
if (extension == null)
{
return;
}
LoggedInUsers.Remove(extension.Username.ToLower());
peer.Disconnected -= OnUserDisconnect;
if (LoggedOut != null)
{
LoggedOut.Invoke(extension);
}
}
public void Invoke(string methodId, IPeer peer, dynamic func, dynamic[] objects)
{
if (string.IsNullOrEmpty(methodId))
{
throw new ArgumentException(nameof(methodId));
}
if (peer == null)
{
throw new ArgumentNullException(nameof(peer));
}
ResponseCallback responseCallback = (rm, sd) => {
func?.Invoke(rm, sd);
};
Ssci.Invoke(methodId, peer, responseCallback, PacketShell(objects));
}
public void Execute(IPeer peer, IPacket packet)
{
cPKTSay recvPacket = (cPKTSay)packet;
cPKTSayResult sendPacket = new cPKTSayResult();
sendPacket.Message = recvPacket.Message;
if (true == cChatRoomManager.Broadcast(peer.PeerId, recvPacket.Message))
{
sendPacket.ResultCode = cPKTSayResult.eResultCode.SUCCEED;
}
else
{
sendPacket.ResultCode = cPKTSayResult.eResultCode.FAILURE;
}
peer.Send(sendPacket);
}
private async Task SendBlockAsync(IPeer peer, BlockWithTransactions blockWithTransactions)
{
try
{
peer.EnqueueBlock(blockWithTransactions, async ex =>
{
if (ex != null)
{
Logger.LogError(ex, $"Error while broadcasting block to {peer}.");
await HandleNetworkException(peer, ex);
}
});
}
catch (NetworkException ex)
{
Logger.LogError(ex, $"Error while broadcasting block to {peer}.");
}
}
/// <summary>
/// Receive packet handler method
/// </summary>
/// <param name="peer">source peer of sending the packet</param>
/// <param name="packet">packet</param>
public void OnReceiveControlPacket(IPeer peer, object packet)
{
object[] gamePacket = packet as object[];
if (gamePacket != null)
{
int switchCode = (int)gamePacket[0];
switch (switchCode)
{
case SimpleGameMetrics.ClientGameSwitchCode.Move:
MoveControl(peer, (float[])gamePacket[1]);
break;
case SimpleGameMetrics.ClientGameSwitchCode.Shoot:
ShootControl(peer);
break;
}
}
}
/// <summary>
/// Peer connected Event
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="peer">Peer</param>
private void PeerConnected(object sender, IPeer peer)
{
try
{
if (_acl.IsAllowed(peer.EndPoint) == false)
{
throw new UnauthorizedAccessException($"The endpoint \"{peer.EndPoint}\" is prohibited by ACL.");
}
_connectedPeers.Add(peer);
_peerMessageListener.StartFor(peer, _messageListenerTokenSource.Token);
}
catch (Exception e)
{
_logger.LogWarning($"Something went wrong with {peer}. Exception: {e}");
peer.Disconnect();
}
}
private void HandleIncomingStatusChangedMessageTypeRecieved(IPeer sender, NetIncomingMessage im)
{
IUser user;
switch (im.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
user = _approvedUsers.First(user => user.Connection == im.SenderConnection);
_approvedUsers.Remove(user);
this.Users.TryAdd(user);
break;
case NetConnectionStatus.Disconnected:
user = this.Users.First(user => user.Connection == im.SenderConnection);
user.TryRelease();
break;
}
}
private void Listener_OnPeerConnected(object sender, IPeer e)
{
lock (this.nodes)
{
var prev = this.nodes
.FirstOrDefault(_ =>
_.Peer.TargetAddress == e.TargetAddress &&
_.Peer.BaseAddress == e.BaseAddress);
if (prev != null)
{
this.nodes.Remove(prev);
}
this.nodes.Add(new ConnectionNode()
{
Peer = e,
});
}
}
public async Task DisconnectAsync(IPeer peer, bool sendDisconnect = false)
{
if (peer == null)
{
throw new ArgumentNullException(nameof(peer));
}
// clean the pool
if (_peerPool.RemovePeer(peer.Info.Pubkey) == null)
{
Logger.LogWarning($"{peer} was not found in pool.");
}
// clean the peer
await peer.DisconnectAsync(sendDisconnect);
Logger.LogDebug($"Removed peer {peer}");
}
public void HandleRemoteFundingLocked(IPeer peer, FundingLockedMessage message, LocalChannel channel)
{
if (channel.State == LocalChannelState.NormalOperation && channel.RemoteCommitmentTxParameters.TransactionNumber == 0)
{
_channelLoggingService.LogInfo(channel, $"Remote sent us a {nameof(FundingLockedMessage)} but we are already in Normal Operation state. " +
"We will answer with a funding locked message.");
SendFundingLocked(peer, channel);
return;
}
if (channel.State != LocalChannelState.FundingSigned && channel.State != LocalChannelState.FundingLocked)
{
_channelLoggingService.LogWarning(channel, $"Remote sent us a {nameof(FundingLockedMessage)}, but the current state is {channel.State}");
return;
}
channel.State = channel.State == LocalChannelState.FundingLocked ? LocalChannelState.NormalOperation : LocalChannelState.FundingLocked;
channel.RemoteCommitmentTxParameters.NextPerCommitmentPoint = message.NextPerCommitmentPoint;
}
public async Task <bool> PeerJoined(IPeer peer, Dictionary <byte, object> peerProperties)
{
if (_roomController == null)
{
_logger.Error($"GameModeController == null while peer joining");
return(false);
}
try
{
return(await _roomController.ProcessNewPlayer(peer.GetSessionId(), peerProperties) &&
_roomPlayers.ContainsKey(peer.GetSessionId()));// if player still in room
}
catch (Exception ex)
{
_logger.Error($"PeerJoined error for player with sessionId = {peer.GetSessionId()}: {ex}");
return(false);
}
}
/// <summary>
/// Fired when registered room peer disconnected from master
/// </summary>
/// <param name="peer"></param>
private void OnRegisteredPeerDisconnect(IPeer peer)
{
Dictionary <int, RegisteredRoom> peerRooms = peer.GetProperty((int)MsfPropCodes.RegisteredRooms) as Dictionary <int, RegisteredRoom>;
if (peerRooms == null)
{
return;
}
logger.Debug($"Client {peer.Id} was disconnected from server and it has registered rooms that also must be destroyed");
// Create a copy so that we can iterate safely
var registeredRooms = peerRooms.Values.ToList();
foreach (var registeredRoom in registeredRooms)
{
DestroyRoom(registeredRoom);
}
}
/// <summary>
/// Removes existing chat user from all the channels, and creates a new
/// <see cref="ChatUserPeerExtension"/> with new username. If <see cref="joinSameChannels"/> is true,
/// user will be added to same channels
/// </summary>
/// <param name="peer"></param>
/// <param name="newUsername"></param>
/// <param name="joinSameChannels"></param>
public void ChangeUsername(IPeer peer, string newUsername, bool joinSameChannels = true)
{
var chatUser = peer.GetExtension <ChatUserPeerExtension>();
if (chatUser == null)
{
return;
}
// Get previous chat user channels that one is connected to
var prevChannels = chatUser.CurrentChannels.ToList();
// Get his default chat channel
var defaultChannel = chatUser.DefaultChannel;
// Remove the user from chat
RemoveChatUser(chatUser);
// Create a new chat user
var newExtension = CreateChatUser(peer, newUsername);
// Replace with new user
peer.AddExtension(newExtension);
if (joinSameChannels)
{
foreach (var prevChannel in prevChannels)
{
var channel = GetOrCreateChannel(prevChannel.Name);
if (channel != null)
{
channel.AddUser(newExtension);
}
}
if (defaultChannel != null && defaultChannel.Users.Contains(newExtension))
{
// If we were added to the chat, which is now set as our default chat
// It's safe to set the default channel
newExtension.DefaultChannel = defaultChannel;
}
}
}
public void Execute(IPeer peer, IPacket packet)
{
cPKTChatRoomChange recvPacket = (cPKTChatRoomChange)packet;
cPKTChatRoomChangeResult resultPacket = new cPKTChatRoomChangeResult();
do
{
cChatPlayer chatPlayer = (cChatPlayer)peer;
if (false == cChatRoomManager.ChangeChatRoom(chatPlayer.AccountId, recvPacket.NewChatRoomIndex))
{
resultPacket.ResultCode = cPKTChatRoomChangeResult.eResultCode.CANNOT_CHANGE_CHAT_ROOM;
break;
}
resultPacket.ResultCode = cPKTChatRoomChangeResult.eResultCode.SUCCEED;
} while (false);
peer.Send(resultPacket);
}
/// <summary>
/// Search and cancel join request from specific list
/// </summary>
/// <param name="reqList">request list</param>
/// <param name="peer">peer of cancellation</param>
/// <param name="msg">cancel message</param>
/// <param name="arg">cancel argument</param>
/// <returns>success of cancellation</returns>
private bool CancelRequestFromList(ref List <JoinGroupRequest> reqList, IPeer peer, string msg = "", object arg = null)
{
JoinGroupRequest request;
lock (reqList)
{
if ((request = reqList.Find(req => req.Peer == peer)) != null)
{
request.Cancel(msg, arg);
reqList.Remove(request);
return(true);
}
else
{
// means not found
return(false);
}
}
}
private bool StartPeer(string[] args)
{
var port = ListenPort;
if (args.Length == 1 && !int.TryParse(args[0], out port))
{
return(Error($"Local server listen port number expected as argument, got {args[0]}"));
}
_peer = Create.NewPeer(port);
var ctx = _peer.Local.Context;
var reg = ctx.Registry;
var scope = ctx.Executor.Scope;
reg.Register(new ClassBuilder <TestClient>(reg).Class);
scope["remote"] = new TestClient();
return(_peer.SelfHost() || Error("Failed to start local server"));
}
private List <IPeer> SelectPeers(string peerPubKey)
{
List <IPeer> peers = new List <IPeer>();
// Get the suggested peer
IPeer suggestedPeer = _peerPool.FindPeerByPublicKey(peerPubKey);
if (suggestedPeer == null)
{
Logger.LogWarning("Could not find suggested peer");
}
else
{
peers.Add(suggestedPeer);
}
// Get our best peer
IPeer bestPeer = _peerPool.GetPeers().FirstOrDefault(p => p.IsBest);
if (bestPeer == null)
{
Logger.LogWarning("No best peer.");
}
else if (bestPeer.Info.Pubkey != peerPubKey)
{
peers.Add(bestPeer);
}
Random rnd = new Random();
// Fill with random peers.
List <IPeer> randomPeers = _peerPool.GetPeers()
.Where(p => p.Info.Pubkey != peerPubKey && (bestPeer == null || p.Info.Pubkey != bestPeer.Info.Pubkey))
.OrderBy(x => rnd.Next())
.Take(NetworkConstants.DefaultMaxRandomPeersPerRequest)
.ToList();
peers.AddRange(randomPeers);
Logger.LogDebug($"Selected {peers.Count} for the request.");
return(peers);
}
private void ListenForIncomingMessages(IPeer peer)
{
Task.Factory.StartNew(async() =>
{
while (peer.IsConnected)
{
var message = await peer.Receive();
if (!peer.IsReady && !IsHandshakeMessage(message))
{
continue;
}
await _messageHandler.Handle(message, peer);
await Task.Delay(1000, _stopTokenSource.Token);
}
}, _stopTokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
private void ListenForMessages(IPeer peer, CancellationToken cancellationToken)
{
Task.Factory.StartNew(async() =>
{
while (peer.IsConnected)
{
var message = await peer.Receive();
if (!peer.IsReady && message.IsNotHandshakeMessage())
{
continue;
}
await this._messageHandler.Handle(message, peer);
await Task.Delay(1000, cancellationToken);
}
}, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
private async Task <Response <T> > Request <T>(IPeer peer, Func <IPeer, Task <T> > func) where T : class
{
try
{
return(new Response <T>(await func(peer)));
}
catch (NetworkException ex)
{
Logger.LogError(ex, $"Error while requesting block(s) from {peer.RemoteEndpoint}.");
if (ex.ExceptionType == NetworkExceptionType.HandlerException)
{
return(new Response <T>(default(T)));
}
await HandleNetworkException(peer, ex);
}
return(new Response <T>());
}
private IInputPeer GetInputPeerFromIPeer(IPeer peer)
{
IInputPeer retInputUser = null;
var peerUser = peer as PeerUser;
var peerChat = peer as PeerChat;
var peerChannel = peer as PeerChannel;
if (peerUser != null)
{
var inputPeerUser = new InputPeerUser
{
UserId = peerUser.UserId
};
retInputUser = inputPeerUser;
}
else if (peerChat != null)
{
var inputPeerChat = new InputPeerChat
{
ChatId = peerChat.ChatId
};
retInputUser = inputPeerChat;
}
else if(peerChannel!= null)
{
var inputPeerChannel = new InputPeerChannel
{
ChannelId = peerChannel.ChannelId,
};
retInputUser = inputPeerChannel;
}
return retInputUser;
}
public async Task CreatePeerDirectoryIfNotExist(IPeer peer)
{
if (this._ftpClient.GetShortDirectoryList().Any(dirName => dirName == peer.EscapePeerAddress()))
{
return;
}
this._ftpClient.MakeDir(peer.EscapePeerAddress());
var createQueueDirectoryTask = Task.Factory.StartNew(() => this._ftpClient.MakeDir(peer.QueueLocation()));
var createSentDirectoryTask = Task.Factory.StartNew(() => this._ftpClient.MakeDir(peer.SentLocation()));
await createQueueDirectoryTask;
await createSentDirectoryTask;
}
public bool RemovePeer(IPeer p)
{
if (_container.Contains(p))
{
_container.Remove(p);
return true;
}
return false;
}
public void RegisterPeer(IPeer p)
{
OnMethodCalled(this, new MethodCallEventArgs{Name = "RegisterPeer", Id = p.Id});
int pid = 0;
bool added = false;
try
{
pid = p.Id;
Console.WriteLine(Id+"- Peer:"+ pid + " Registered.");
if (RegisteredPeers.ContainsKey(pid))
{
throw new PeerAlreadyRegisteredException();
}
RegisteredPeers.Add(pid, p);
added = true;
}
catch (WebException)
{
if (added)
RegisteredPeers.Remove(pid);
}
}
private IInputPeer GetInputPeerFromIPeer(IPeer peer)
{
IInputPeer retInputUser = null;
var peerUser = peer as PeerUser;
var peerChat = peer as PeerChat;
var peerChannel = peer as PeerChannel;
if (peerUser != null)
{
var inputPeerUser = new InputPeerUser
{
UserId = peerUser.UserId
};
retInputUser = inputPeerUser;
}
else if (peerChat != null)
{
var inputPeerChat = new InputPeerChat
{
ChatId = peerChat.ChatId
};
retInputUser = inputPeerChat;
}
else if(peerChannel!= null)
{
var inputPeerChannel = new InputPeerChannel
{
ChannelId = peerChannel.ChannelId,
AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(peerChannel.ChannelId))
};
retInputUser = inputPeerChannel;
}
return retInputUser;
}
/// <summary>
/// ���� ������ ȣ��� �ݹ� �żҵ�.
/// </summary>
/// <param name="server_token"></param>
void on_connected_gameserver(CUserToken server_token)
{
this.gameserver = new CRemoteServerPeer(server_token);
((CRemoteServerPeer)this.gameserver).set_eventmanager(this.event_manager);
// ����Ƽ ���ø����̼����� �̺�Ʈ�� �Ѱ��ֱ� ���ؼ� �Ŵ����� ť�� ���� �ش�.
this.event_manager.enqueue_network_event(NETWORK_EVENT.connected);
}
