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);
}
