public void Parse_Returns_Expected_Data_When_1_User(string roomName)
{
var builder = new MessageBuilder()
.WriteCode(MessageCode.Server.JoinRoom)
.WriteString(roomName)
.WriteInteger(1) // user count
.WriteString("1")
.WriteInteger(1) // status count
.WriteInteger((int)UserPresence.Online)
.WriteInteger(1) // data count
.WriteInteger(10) // average speed
.WriteLong(11) // download count
.WriteInteger(12) // file count
.WriteInteger(13) // directory count
.WriteInteger(1) // slots free count
.WriteInteger(14) // slots free
.WriteInteger(1) // country count
.WriteString("US");
var res = RoomJoinResponse.FromByteArray(builder.Build());
var users = res.Users.ToList();
Assert.Equal(roomName, res.Name);
Assert.Equal(1, res.UserCount);
Assert.Equal("1", users[0].Username);
Assert.Equal(UserPresence.Online, users[0].Status);
Assert.Equal(10, users[0].AverageSpeed);
Assert.Equal(11, users[0].DownloadCount);
Assert.Equal(12, users[0].FileCount);
Assert.Equal(13, users[0].DirectoryCount);
Assert.Equal(14, users[0].SlotsFree);
Assert.Equal("US", users[0].CountryCode);
}
public override void Execute(string packet)
{
RoomJoinResponse roomJoinResponse = JsonConvert.DeserializeObject <RoomJoinResponse>(packet);
switch (roomJoinResponse.Status)
{
case ResponseStatus.Ok:
Application.Current.Dispatcher.Invoke(() =>
{
SetPage(new Game());
});
break;
case ResponseStatus.RoomIsFull:
//(ClientObject.view as RoomViewModel).Status = "Комната полна";
MessageBox.Show("Комната полна");
break;
case ResponseStatus.Bad:
//(ClientObject.view as RoomViewModel).Status = "Ошибка";
MessageBox.Show("Ошибка на стороне сервера");
break;
}
}
public void Parse_Throws_MessageException_On_Code_Mismatch()
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.LeaveRoom)
.Build();
var ex = Record.Exception(() => RoomJoinResponse.FromByteArray(msg));
Assert.NotNull(ex);
Assert.IsType <MessageException>(ex);
}
public void Parse_Throws_MessageReadException_On_Missing_Data()
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.JoinRoom)
.WriteInteger(1)
.Build();
var ex = Record.Exception(() => RoomJoinResponse.FromByteArray(msg));
Assert.NotNull(ex);
Assert.IsType <MessageReadException>(ex);
}
public void Parse_Returns_Expected_Data_When_0_Users(string roomName)
{
var builder = new MessageBuilder()
.WriteCode(MessageCode.Server.JoinRoom)
.WriteString(roomName)
.WriteInteger(0) // user count
.WriteInteger(0) // status count
.WriteInteger(0) // data count
.WriteInteger(0) // slots free count
.WriteInteger(0); // country count
var response = RoomJoinResponse.FromByteArray(builder.Build());
Assert.Equal(roomName, response.Name);
Assert.Equal(0, response.UserCount);
}
private void OnSuccessRoomJoin(RoomJoinResponse roomJoinResponse)
{
Debug.Log("room_id " + roomJoinResponse.room_id + " : " + "time_remaining " + roomJoinResponse.time_remaining);
if (roomJoinResponse.code == 0)
{
roomJoinUiController.EnableRoomJoinWaitingScreen(false);
GamePlayManager.GetInstance.SocketRoomJoin(roomJoinResponse.room_id);
}
else if (roomJoinResponse.code == GameVariables.CodeType.InvalidRoomId)
{
roomJoinUiController.PrintRoomJoinErrorMessage("Entered room id is invalid.");
}
else if (roomJoinResponse.code == GameVariables.CodeType.CannotJoinRoom || roomJoinResponse.code == GameVariables.CodeType.RoomIsActive || roomJoinResponse.code == GameVariables.CodeType.RoomIsClosed)
{
roomJoinUiController.PrintRoomJoinErrorMessage("Cannot join room!, Match has already started or finished.");
}
DisableLoadingUi();
}
public void Excecute(ClientObject client, ServerObject server, RoomObject room, string packet = "")
{
var request = JsonConvert.DeserializeObject <RoomJoinRequest>(packet);
Console.WriteLine($"Join to room {request.Room.Name}");
var roomObject = server.GetRoomById(request.Room.Id);
var response = new RoomJoinResponse();
//если запрашиваемае комната существует
if (roomObject != null)
{
//если нету свободных мест в комнате
if (roomObject.Info.PlayersCount >= roomObject.Info.Size)
{
response.Status = ResponseStatus.RoomIsFull;
}
else
{
//конектим пользователя к комнате
server.ConnectToRoom(client, roomObject);
response.Status = ResponseStatus.Ok;
if (roomObject.Game.IsEmptyTableQuestions())
{
roomObject.Game.TableQuestions = DB.GetQuestionsTable();
}
Console.WriteLine($"User {client.Player.Login} connect to room {roomObject.Info.Name}");
}
}
else
{
response.Status = ResponseStatus.Bad;
}
Console.WriteLine($"Join to room status: {response.Status.ToString()}");
string packetResponse = JsonConvert.SerializeObject(response);
//отправляем пользователю статус подключения к комнате
roomObject.SendMessageToDefiniteClient(packetResponse, client);
//----------------------------------------------------------------------------//
NotifyTempUsersAboutUpdateRooms(server);
//---------------------Отправить игрокам комнаты информацию об новом игроке----------------------//
NotifyPlayersAboutUpdateRooms(roomObject);
//---------------------Отправить игроку комнаты информации о игре----------------------//
server.Commands[RequestType.GetRoomInfo]?.Excecute(client, server, roomObject);
}
/// <summary>
/// Handles incoming messages.
/// </summary>
/// <param name="sender">The <see cref="IMessageConnection"/> instance from which the message originated.</param>
/// <param name="message">The message.</param>
public async void HandleMessageRead(object sender, byte[] message)
{
var code = new MessageReader <MessageCode.Server>(message).ReadCode();
if (code != MessageCode.Server.SearchRequest)
{
Diagnostic.Debug($"Server message received: {code}");
}
try
{
switch (code)
{
case MessageCode.Server.ParentMinSpeed:
case MessageCode.Server.ParentSpeedRatio:
case MessageCode.Server.WishlistInterval:
case MessageCode.Server.CheckPrivileges:
SoulseekClient.Waiter.Complete(new WaitKey(code), IntegerResponse.FromByteArray <MessageCode.Server>(message));
break;
case MessageCode.Server.NewPassword:
var confirmedPassword = NewPassword.FromByteArray(message).Password;
SoulseekClient.Waiter.Complete(new WaitKey(code), confirmedPassword);
break;
case MessageCode.Server.GlobalAdminMessage:
var msg = GlobalMessageNotification.FromByteArray(message);
GlobalMessageReceived?.Invoke(this, new GlobalMessageReceivedEventArgs(msg));
break;
case MessageCode.Server.Ping:
SoulseekClient.Waiter.Complete(new WaitKey(code));
break;
case MessageCode.Server.Login:
SoulseekClient.Waiter.Complete(new WaitKey(code), LoginResponse.FromByteArray(message));
break;
case MessageCode.Server.RoomList:
var roomList = RoomListResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code), roomList);
RoomListReceived?.Invoke(this, new RoomListReceivedEventArgs(roomList));
break;
case MessageCode.Server.PrivilegedUsers:
var privilegedUserList = PrivilegedUserListNotification.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code), privilegedUserList);
PrivilegedUserListReceived?.Invoke(this, new PrivilegedUserListReceivedEventArgs(privilegedUserList));
break;
case MessageCode.Server.AddPrivilegedUser:
PrivilegeNotificationReceived?.Invoke(this, new PrivilegeNotificationReceivedEventArgs(PrivilegedUserNotification.FromByteArray(message)));
break;
case MessageCode.Server.NotifyPrivileges:
var pn = PrivilegeNotification.FromByteArray(message);
PrivilegeNotificationReceived?.Invoke(this, new PrivilegeNotificationReceivedEventArgs(pn.Username, pn.Id));
if (SoulseekClient.Options.AutoAcknowledgePrivilegeNotifications)
{
await SoulseekClient.AcknowledgePrivilegeNotificationAsync(pn.Id, CancellationToken.None).ConfigureAwait(false);
}
break;
case MessageCode.Server.UserPrivileges:
var privilegeResponse = UserPrivilegeResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code, privilegeResponse.Username), privilegeResponse.IsPrivileged);
break;
case MessageCode.Server.NetInfo:
var netInfo = NetInfoNotification.FromByteArray(message);
try
{
var parents = netInfo.Parents.Select(parent => (parent.Username, new IPEndPoint(parent.IPAddress, parent.Port)));
await SoulseekClient.DistributedConnectionManager.AddParentConnectionAsync(parents).ConfigureAwait(false);
}
catch (Exception ex)
{
Diagnostic.Debug($"Error handling NetInfo message: {ex.Message}");
}
break;
case MessageCode.Server.ConnectToPeer:
ConnectToPeerResponse connectToPeerResponse = default;
try
{
connectToPeerResponse = ConnectToPeerResponse.FromByteArray(message);
if (connectToPeerResponse.Type == Constants.ConnectionType.Transfer)
{
Diagnostic.Debug($"Received transfer ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for remote token {connectToPeerResponse.Token}");
// ensure that we are expecting at least one file from this user before we connect. the response
// doesn't contain any other identifying information about the file.
if (!SoulseekClient.Downloads.IsEmpty && SoulseekClient.Downloads.Values.Any(d => d.Username == connectToPeerResponse.Username))
{
var(connection, remoteToken) = await SoulseekClient.PeerConnectionManager.GetTransferConnectionAsync(connectToPeerResponse).ConfigureAwait(false);
var download = SoulseekClient.Downloads.Values.FirstOrDefault(v => v.RemoteToken == remoteToken && v.Username == connectToPeerResponse.Username);
if (download != default(TransferInternal))
{
Diagnostic.Debug($"Solicited inbound transfer connection to {download.Username} ({connection.IPEndPoint}) for token {download.Token} (remote: {download.RemoteToken}) established. (id: {connection.Id})");
SoulseekClient.Waiter.Complete(new WaitKey(Constants.WaitKey.IndirectTransfer, download.Username, download.Filename, download.RemoteToken), connection);
}
else
{
Diagnostic.Debug($"Transfer ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for remote token {connectToPeerResponse.Token} does not match any waiting downloads, discarding.");
connection.Disconnect($"Unknown transfer");
}
}
else
{
throw new SoulseekClientException($"Unexpected transfer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}); Ignored");
}
}
else if (connectToPeerResponse.Type == Constants.ConnectionType.Peer)
{
Diagnostic.Debug($"Received message ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint})");
await SoulseekClient.PeerConnectionManager.GetOrAddMessageConnectionAsync(connectToPeerResponse).ConfigureAwait(false);
}
else if (connectToPeerResponse.Type == Constants.ConnectionType.Distributed)
{
Diagnostic.Debug($"Received distributed ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint})");
await SoulseekClient.DistributedConnectionManager.AddChildConnectionAsync(connectToPeerResponse).ConfigureAwait(false);
}
else
{
throw new MessageException($"Unknown Connect To Peer connection type '{connectToPeerResponse.Type}'");
}
}
catch (Exception ex)
{
Diagnostic.Debug($"Error handling ConnectToPeer response from {connectToPeerResponse?.Username} ({connectToPeerResponse?.IPEndPoint}): {ex.Message}");
}
break;
case MessageCode.Server.AddUser:
var addUserResponse = AddUserResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code, addUserResponse.Username), addUserResponse);
break;
case MessageCode.Server.GetStatus:
var statsResponse = UserStatusResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code, statsResponse.Username), statsResponse);
UserStatusChanged?.Invoke(this, new UserStatusChangedEventArgs(statsResponse));
break;
case MessageCode.Server.PrivateMessage:
var pm = PrivateMessageNotification.FromByteArray(message);
PrivateMessageReceived?.Invoke(this, new PrivateMessageReceivedEventArgs(pm));
if (SoulseekClient.Options.AutoAcknowledgePrivateMessages)
{
await SoulseekClient.AcknowledgePrivateMessageAsync(pm.Id, CancellationToken.None).ConfigureAwait(false);
}
break;
case MessageCode.Server.GetPeerAddress:
var peerAddressResponse = UserAddressResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code, peerAddressResponse.Username), peerAddressResponse);
break;
case MessageCode.Server.JoinRoom:
var roomData = RoomJoinResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code, roomData.Name), roomData);
break;
case MessageCode.Server.LeaveRoom:
var leaveRoomResponse = RoomLeaveResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(code, leaveRoomResponse.RoomName));
break;
case MessageCode.Server.SayInChatRoom:
var roomMessage = RoomMessageNotification.FromByteArray(message);
RoomMessageReceived?.Invoke(this, new RoomMessageReceivedEventArgs(roomMessage));
break;
case MessageCode.Server.UserJoinedRoom:
var joinNotification = RoomJoinedNotification.FromByteArray(message);
RoomJoined?.Invoke(this, new RoomJoinedEventArgs(joinNotification));
break;
case MessageCode.Server.UserLeftRoom:
var leftNotification = RoomLeftNotification.FromByteArray(message);
RoomLeft?.Invoke(this, new RoomLeftEventArgs(leftNotification));
break;
case MessageCode.Server.KickedFromServer:
KickedFromServer?.Invoke(this, EventArgs.Empty);
break;
case MessageCode.Server.FileSearch:
var searchRequest = ServerSearchRequest.FromByteArray(message);
// sometimes (most of the time?) a room search will result in a request to ourselves (assuming we are
// joined to it)
if (searchRequest.Username == SoulseekClient.Username)
{
break;
}
SearchResponse searchResponse;
if (SoulseekClient.Options.SearchResponseResolver == default)
{
break;
}
try
{
searchResponse = await SoulseekClient.Options.SearchResponseResolver(searchRequest.Username, searchRequest.Token, SearchQuery.FromText(searchRequest.Query)).ConfigureAwait(false);
if (searchResponse != null && searchResponse.FileCount + searchResponse.LockedFileCount > 0)
{
var endpoint = await SoulseekClient.GetUserEndPointAsync(searchRequest.Username).ConfigureAwait(false);
var peerConnection = await SoulseekClient.PeerConnectionManager.GetOrAddMessageConnectionAsync(searchRequest.Username, endpoint, CancellationToken.None).ConfigureAwait(false);
await peerConnection.WriteAsync(searchResponse.ToByteArray()).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Diagnostic.Warning($"Error resolving search response for query '{searchRequest.Query}' requested by {searchRequest.Username} with token {searchRequest.Token}: {ex.Message}", ex);
}
break;
// if we fail to connect to a distributed parent in a timely manner, the server will begin to send us distributed search requests directly.
// forward these to the distributed message handler.
case MessageCode.Server.SearchRequest:
SoulseekClient.DistributedMessageHandler.HandleMessageRead(SoulseekClient.ServerConnection, message);
break;
default:
Diagnostic.Debug($"Unhandled server message: {code}; {message.Length} bytes");
break;
}
}
catch (Exception ex)
{
Diagnostic.Warning($"Error handling server message: {code}; {ex.Message}", ex);
}
}