protected virtual void OnChatMessageHandler(IIncomingMessage message) { try { var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>(); // If peer has no user if (chatUser == null) { throw new MstMessageHandlerException("Chat cannot identify you", ResponseStatus.Unauthorized); } var packet = message.Deserialize(new ChatMessagePacket()); if (!TryHandleChatMessage(packet, chatUser, message)) { throw new MstMessageHandlerException("Invalid message", ResponseStatus.NotHandled); } } // If we got system exception catch (MstMessageHandlerException e) { logger.Error(e.Message); message.Respond(e.Message, e.Status); } // If we got another exception catch (Exception e) { logger.Error(e.Message); message.Respond(e.Message, ResponseStatus.Error); } }
/// <summary> /// Handles a message from spawned process. Spawned process send this message /// to notify server that it was started /// </summary> /// <param name="message"></param> protected virtual void RegisterSpawnedProcessRequestHandler(IIncomingMessage message) { var data = message.Deserialize(new RegisterSpawnedProcessPacket()); // Try get psawn task by ID if (!spawnTasksList.TryGetValue(data.SpawnId, out SpawnTask task)) { message.Respond("Invalid spawn task", ResponseStatus.Failed); logger.Error("Process tried to register to an unknown task"); return; } // Check spawn task unique code if (task.UniqueCode != data.SpawnCode) { message.Respond("Unauthorized", ResponseStatus.Unauthorized); logger.Error("Spawned process tried to register, but failed due to mismaching unique code"); return; } // Set task as registered task.OnRegistered(message.Peer); // Invoke event OnSpawnedProcessRegisteredEvent?.Invoke(task, message.Peer); // Respon to requester message.Respond(task.Options.ToDictionary().ToBytes(), ResponseStatus.Success); }
protected virtual void GetRoomAccessRequestHandler(IIncomingMessage message) { var data = message.Deserialize(new RoomAccessRequestPacket()); // Let's find a room by Id which the player wants to join if (!roomsList.TryGetValue(data.RoomId, out RegisteredRoom room)) { message.Respond("Room does not exist", ResponseStatus.Failed); return; } // If room requires the password and given password is not valid if (!string.IsNullOrEmpty(room.Options.Password) && room.Options.Password != data.Password) { message.Respond("Invalid password", ResponseStatus.Unauthorized); return; } // Send room access request to peer who owns it room.GetAccess(message.Peer, data.CustomOptions, (packet, error) => { if (packet == null) { message.Respond(error, ResponseStatus.Unauthorized); return; } message.Respond(packet, ResponseStatus.Success); }); }
protected virtual void JoinLobbyTeamMessageHandler(IIncomingMessage message) { var data = message.Deserialize(new LobbyJoinTeamPacket()); var lobbiesExt = GetOrCreateLobbyUserPeerExtension(message.Peer); var lobby = lobbiesExt.CurrentLobby; if (lobby == null) { message.Respond("You're not in a lobby", ResponseStatus.Failed); return; } var player = lobby.GetMemberByExtension(lobbiesExt); if (player == null) { message.Respond("Invalid request", ResponseStatus.Failed); return; } if (!lobby.TryJoinTeam(data.TeamName, player)) { message.Respond("Failed to join a team: " + data.TeamName, ResponseStatus.Failed); return; } message.Respond(ResponseStatus.Success); }
protected virtual void SetLobbyPropertiesMessageHandler(IIncomingMessage message) { var data = message.Deserialize(new LobbyPropertiesSetPacket()); lobbies.TryGetValue(data.LobbyId, out ILobby lobby); if (lobby == null) { message.Respond("Lobby was not found", ResponseStatus.Failed); return; } var lobbiesExt = GetOrCreateLobbyUserPeerExtension(message.Peer); foreach (var dataProperty in data.Properties.ToDictionary()) { if (!lobby.SetProperty(lobbiesExt, dataProperty.Key, dataProperty.Value)) { message.Respond("Failed to set the property: " + dataProperty.Key, ResponseStatus.Failed); return; } } message.Respond(ResponseStatus.Success); }
private void HandleLobbyMemberJoinedMsg(IIncomingMessage message) { var data = message.Deserialize(new LobbyMemberData()); Members[data.Username] = data; Listener?.OnMemberJoined(data); }
protected virtual void OnChatMessageHandler(IIncomingMessage message) { var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>(); string responseMsg; if (chatUser == null) { responseMsg = "Chat cannot identify you"; logger.Error(responseMsg); message.Respond(responseMsg, ResponseStatus.Unauthorized); return; } var packet = message.Deserialize(new ChatMessagePacket()); if (!TryHandleChatMessage(packet, chatUser, message)) { responseMsg = "Invalid message"; logger.Error(responseMsg); // If message was not handled message.Respond(responseMsg, ResponseStatus.NotHandled); return; } }
private void HandleLobbyPropertyChanged(IIncomingMessage message) { var data = message.Deserialize(new StringPairPacket()); Properties[data.A] = data.B; Listener?.OnLobbyPropertyChanged(data.A, data.B); }
private void SetSpawnedProcessesCountRequestHandler(IIncomingMessage message) { var packet = message.Deserialize(new IntPairPacket()); if (spawnersList.TryGetValue(packet.A, out RegisteredSpawner spawner)) { spawner.UpdateProcessesCount(packet.B); } }
private void OnChatMessageHandler(IIncomingMessage message) { var packet = message.Deserialize(new ChatMessagePacket()); if (OnMessageReceivedEvent != null) { OnMessageReceivedEvent.Invoke(packet); } }
/// <summary> /// Fires when new status received /// </summary> /// <param name="message"></param> private static void StatusUpdateHandler(IIncomingMessage message) { var data = message.Deserialize(new SpawnStatusUpdatePacket()); Logs.Debug($"Status changed to {data.Status}"); if (Mst.Client.Spawners.TryGetRequestController(data.SpawnId, out SpawnRequestController controller)) { controller.Status = data.Status; controller.OnStatusChangedEvent?.Invoke(data.Status); } }
private void HandleLobbyMemberReadyStatusChangeMsg(IIncomingMessage message) { var data = message.Deserialize(new StringPairPacket()); Members.TryGetValue(data.A, out LobbyMemberData member); if (member == null) { return; } member.IsReady = bool.Parse(data.B); Listener?.OnMemberReadyStatusChanged(member, member.IsReady); }
/// <summary> /// Handles spawn request for all controllers filtered by ID /// </summary> /// <param name="message"></param> private static void SpawnProcessRequestHandler(IIncomingMessage message) { var data = message.Deserialize(new SpawnRequestPacket()); var controller = Mst.Server.Spawners.GetController(data.SpawnerId) as SpawnerController; if (controller == null) { if (message.IsExpectingResponse) { message.Respond("Couldn't find a spawn controller", ResponseStatus.NotHandled); } return; } controller.Logger.Debug($"Spawn process requested for spawn controller [{controller.SpawnerId}]"); controller.SpawnRequestHandler(data, message); }
protected virtual void RegisterSpawnerRequestHandler(IIncomingMessage message) { logger.Debug($"Client [{message.Peer.Id}] requested to be registered as spawner"); if (!HasCreationPermissions(message.Peer)) { message.Respond("Insufficient permissions", ResponseStatus.Unauthorized); return; } var options = message.Deserialize(new SpawnerOptions()); var spawner = CreateSpawner(message.Peer, options); logger.Debug($"Client [{message.Peer.Id}] was successfully registered as spawner [{spawner.SpawnerId}] with options: {options}"); // Respond with spawner id message.Respond(spawner.SpawnerId, ResponseStatus.Success); }
protected virtual void RegisterRoomRequestHandler(IIncomingMessage message) { logger.Debug($"Client {message.Peer.Id} requested to register new room server"); if (!HasRoomRegistrationPermissions(message.Peer)) { logger.Debug($"But it has no permission"); message.Respond("Insufficient permissions", ResponseStatus.Unauthorized); return; } var options = message.Deserialize(new RoomOptions()); var room = RegisterRoom(message.Peer, options); logger.Debug($"Room {room.RoomId} has been successfully registered with options: {options}"); // Respond with a room id message.Respond(room.RoomId, ResponseStatus.Success); }
protected virtual void ValidateRoomAccessRequestHandler(IIncomingMessage message) { // Parse message var data = message.Deserialize(new RoomAccessValidatePacket()); // Trying to find room in list of registered if (!roomsList.TryGetValue(data.RoomId, out RegisteredRoom room)) { message.Respond("Room does not exist", ResponseStatus.Failed); return; } // if this message is not received from owner of room if (message.Peer != room.Peer) { // Wrong peer of room registrar message.Respond("You're not the registrar of the room", ResponseStatus.Unauthorized); return; } // Trying to validate room access token if (!room.ValidateAccess(data.Token, out IPeer playerPeer)) { message.Respond("Failed to confirm the access", ResponseStatus.Unauthorized); return; } var packet = new UsernameAndPeerIdPacket() { PeerId = playerPeer.Id }; // Add username if available var userExt = playerPeer.GetExtension <IUserPeerExtension>(); if (userExt != null) { packet.Username = userExt.Username ?? ""; } // Respond with success and player's peer id message.Respond(packet, ResponseStatus.Success); }
private void HandleMemberPropertyChanged(IIncomingMessage message) { var data = message.Deserialize(new LobbyMemberPropChangePacket()); if (Id != data.LobbyId) { return; } Members.TryGetValue(data.Username, out LobbyMemberData member); if (member == null) { return; } member.Properties.Set(data.Property, data.Value); Listener?.OnMemberPropertyChanged(member, data.Property, data.Value); }
protected virtual void SaveRoomOptionsRequestHandler(IIncomingMessage message) { var data = message.Deserialize(new SaveRoomOptionsPacket()); if (!roomsList.TryGetValue(data.RoomId, out RegisteredRoom room)) { message.Respond("Room does not exist", ResponseStatus.Failed); return; } if (message.Peer != room.Peer) { // Wrong peer unregistering the room message.Respond("You're not the creator of the room", ResponseStatus.Unauthorized); return; } ChangeRoomOptions(room, data.Options); message.Respond(ResponseStatus.Success); }
private void HandlePlayerTeamChangeMsg(IIncomingMessage message) { var data = message.Deserialize(new StringPairPacket()); Members.TryGetValue(data.A, out LobbyMemberData member); if (member == null) { return; } Teams.TryGetValue(data.B, out LobbyTeamData newTeam); if (newTeam == null) { return; } member.Team = newTeam.Name; Listener?.OnMemberTeamChanged(member, newTeam); }
protected virtual void CompleteSpawnProcessRequestHandler(IIncomingMessage message) { var data = message.Deserialize(new SpawnFinalizationPacket()); if (spawnTasksList.TryGetValue(data.SpawnTaskId, out SpawnTask task)) { if (task.RegisteredPeer != message.Peer) { message.Respond("Unauthorized", ResponseStatus.Unauthorized); logger.Error("Spawned process tried to complete spawn task, but it's not the same peer who registered to the task"); } else { task.OnFinalized(data); message.Respond(ResponseStatus.Success); } } else { message.Respond("Invalid spawn task", ResponseStatus.Failed); logger.Error("Process tried to complete to an unknown task"); } }
protected virtual void GetLobbyMemberDataMessageHandler(IIncomingMessage message) { var data = message.Deserialize(new IntPairPacket()); var lobbyId = data.A; var peerId = data.B; lobbies.TryGetValue(lobbyId, out ILobby lobby); if (lobby == null) { message.Respond("Lobby not found", ResponseStatus.Failed); return; } var member = lobby.GetMemberByPeerId(peerId); if (member == null) { message.Respond("Player is not in the lobby", ResponseStatus.Failed); return; } message.Respond(member.GenerateDataPacket(), ResponseStatus.Success); }
private void ProvideRoomAccessCheckHandler(IIncomingMessage message) { var provideRoomAccessCheckPacket = message.Deserialize(new ProvideRoomAccessCheckPacket()); var roomController = Mst.Server.Rooms.GetRoomController(provideRoomAccessCheckPacket.RoomId); if (roomController == null) { message.Respond($"There's no room controller with room id {provideRoomAccessCheckPacket.RoomId}", ResponseStatus.NotHandled); return; } var isProviderDone = false; var requester = new UsernameAndPeerIdPacket() { PeerId = provideRoomAccessCheckPacket.PeerId, Username = provideRoomAccessCheckPacket.Username }; // Create access provider check options var roomAccessProviderCheck = new RoomAccessProviderCheck() { PeerId = provideRoomAccessCheckPacket.PeerId, Username = provideRoomAccessCheckPacket.Username, CustomOptions = provideRoomAccessCheckPacket.CustomOptions }; // Invoke the access provider roomController.AccessProvider.Invoke(roomAccessProviderCheck, (access, error) => { // In case provider timed out if (isProviderDone) { return; } isProviderDone = true; if (access == null) { // If access is not provided message.Respond(string.IsNullOrEmpty(error) ? "" : error, ResponseStatus.Failed); return; } message.Respond(access, ResponseStatus.Success); if (Logger.IsLogging(LogLevel.Trace)) { Logger.Trace("Room controller gave address to peer " + provideRoomAccessCheckPacket.PeerId + ":" + access); } }); // Timeout the access provider MstTimer.WaitForSeconds(Mst.Server.Rooms.AccessProviderTimeout, () => { if (!isProviderDone) { isProviderDone = true; message.Respond("Timed out", ResponseStatus.Timeout); Logger.Error($"Access provider took longer than {Mst.Server.Rooms.AccessProviderTimeout} seconds to provide access. " + "If it's intended, increase the threshold at Msf.Server.Rooms.AccessProviderTimeout"); } }); }
/// <summary> /// Fired whe connected client has made request to spawn process /// </summary> /// <param name="message"></param> protected virtual void ClientsSpawnRequestHandler(IIncomingMessage message) { // Parse data from message var spawnRequestData = message.Deserialize(new ClientsSpawnRequestPacket()); var peer = message.Peer; logger.Info($"Client {peer.Id} requested to spawn room with options: {spawnRequestData}"); if (spawnersList.Count == 0) { logger.Error("But no registered spawner was found!"); message.Respond("No registered spawner was found", ResponseStatus.Failed); return; } // Check if current request is authorized if (!CanClientSpawn(peer, spawnRequestData)) { logger.Error("Unauthorized request"); // Client can't spawn message.Respond("Unauthorized", ResponseStatus.Unauthorized); return; } // Try to find existing request to prevent new one SpawnTask prevRequest = peer.GetProperty((int)MstPeerPropertyCodes.ClientSpawnRequest) as SpawnTask; if (prevRequest != null && !prevRequest.IsDoneStartingProcess) { logger.Warn("And he already has an active request"); // Client has unfinished request message.Respond("You already have an active request", ResponseStatus.Failed); return; } // Create a new spawn task var task = Spawn(spawnRequestData.Options, spawnRequestData.Options.AsString(MstDictKeys.ROOM_REGION), spawnRequestData.CustomOptions); // If spawn task is not created if (task == null) { logger.Warn("But all the servers are busy. Let him try again later"); message.Respond("All the servers are busy. Try again later".ToBytes(), ResponseStatus.Failed); return; } // Save spawn task requester task.Requester = message.Peer; // Save the task as peer property peer.SetProperty((int)MstPeerPropertyCodes.ClientSpawnRequest, task); // Listen to status changes task.OnStatusChangedEvent += (status) => { // Send status update var msg = Mst.Create.Message((short)MstMessageCodes.SpawnRequestStatusChange, new SpawnStatusUpdatePacket() { SpawnId = task.Id, Status = status }); if (task.Requester != null && task.Requester.IsConnected) { message.Peer.SendMessage(msg); } }; message.Respond(task.Id, ResponseStatus.Success); }
private void HandleLobbyChatMessageMsg(IIncomingMessage message) { var msg = message.Deserialize(new LobbyChatPacket()); Listener?.OnChatMessageReceived(msg); }