private async Task <MessageRedisLoginDataResponse> PublishToSlave(AccountModel am, LoginResponse lr, IPAddress clientAddress)
{
// Publish login to redis to notify appropriate slave
try
{
var msg = new NetworkMessageContainer();
msg.MessageData = new ClientLoginDataRequest(
_instanceId,
am.Id,
am.LastSystemID,
lr.IV,
lr.Key,
am.Username,
am.Password,
clientAddress.GetAddressBytes()
);
msg.MessageType = MessageTypes.Redis_LoginDataRequest;
_redisServer.PublishObject(MessageTypes.Redis_LoginDataRequest, msg);
}
catch (Exception e)
{
_logger.Log(e.Message, LogLevel.Error);
}
return(await _getResponse(am.Id));
}
void _GameStateNetworkingManager_MessageReceived(object sender, NetworkMessageContainer e)
{
switch (e.MessageType)
{
case MessageTypes.EnterColony:
{
_gameStateManager.SetState(GameStateType.Colony);
break;
}
case MessageTypes.PortDockApproval:
{
_gameStateManager.SetState(GameStateType.Port);
break;
}
case MessageTypes.PlanetLandApproval:
{
_gameStateManager.SetState(GameStateType.Planet);
break;
}
case MessageTypes.StarSystemData:
{
_gameStateManager.SetState(GameStateType.Space);
break;
}
case MessageTypes.WarpApproval:
{
_gameStateManager.SetState(GameStateType.Space);
break;
}
}
}
public List <OutboundChatMessage> ParseChatline(ChatMetaData meta)
{
if (meta.Arguments == null || meta.Arguments.Trim().Length == 0)
{
return(new List <OutboundChatMessage>()
{
new OutboundChatMessage(meta.Player, new ChatlineObject("Invalid shout command.", ChatlineColor.White))
});
}
var actionText = meta.Player.Username + " " + ChatText.Shout.ToString() + ": ";
var message = new ChatlineObject(new List <ChatlineFragment>()
{
new ChatlineFragment(actionText, ChatlineColor.Lime),
new ChatlineFragment(meta.Arguments, ChatlineColor.White)
});
NetworkMessageContainer msg = new NetworkMessageContainer();
msg.MessageData = new MessageRedisShout(meta.Player.Id, message.ToClientJson());
msg.MessageType = MessageTypes.Redis_Shout;
_redisServer.PublishObject(
MessageTypes.Redis_Shout,
msg
);
return(null);
}
protected virtual void _playableStateManager_MessageReceived(object sender, NetworkMessageContainer e)
{
if (Status == GameStateStatus.Active || Status == GameStateStatus.Activating)
{
if (_checkActiveMessages(e.MessageData, e.MessageType))
{
return;
}
}
switch (e.MessageType)
{
#region Receieve Login Information (State, etc)
case (MessageTypes.ClientLoginSuccess): //Login Successful
{
_targetingService.DisableTargetSetting(); //Suspended until gamestate is read, where it should be enabled
var data = e.MessageData as MessageClientLogin;
_clientShipManager.RemoveAllShips();
_clientShipManager.CurrentCash = data.CurrentCash;
_clientPlayerInfoManager.PlayerID = data.PlayerInfo.PlayerID;
MessageReader.InstantiateShip(data.Ship, _physicsManager.World, _clientShipManager, true);
string incomingMessage = data.LoginMessage;
return;
}
#endregion
}
}
async Task <dynamic> _pushColonyData(dynamic parameters, CancellationToken cancellationToken)
{
var mockResponses = new MockResponses();
// Not sure if this works if there are unassigned properties
var pushColonyData = this.BindAndValidate <MessageColonyDataPush>();
Console.WriteLine("Received Push Data Request ${0}", pushColonyData);
var fakeResponse = mockResponses.GetFakeColonyData();
var msg = new NetworkMessageContainer();
msg.MessageData = pushColonyData;
// Slave gets data here
_redisServer.PublishObject(MessageTypes.Redis_ColonyDataPush, msg);
// Dunno what you plan to do here Free, but the server will have received the push by this point
//fakeResponse.Pages.Overview.Sliders = pushColonyData.Sliders;
return(ReturnJsonResponse(fakeResponse));
}
void _handleSlaveConnectionResponse(object sender, NetworkMessageContainer messageData)
{
if (!_awaitingConnectionResponse)
{
return;
}
var data = messageData.MessageData as MessageSlaveConnectionResponse;
if (data.SlaveID != SlaveID.Value)
{
return;
}
if (data.IsSuccessful)
{
_awaitingConnectionResponse = false;
_connected = true;
_redisServer.Subscribe(ChannelTypes.MasterSlave, SlaveID.Value, _handleSlaveDisconnectionDetected);
return;
}
// Attempt connection again
_connectToServer();
}
/// <summary>
/// The message recieved from the client will have the /t, /s, etc removed
/// Function handles chat message according to chat type which is sent as a byte by the client
/// </summary>
/// <param name="msg"></param>
/// <param name="server"></param>
/// <param name="messageConnection"></param>
public async void HandleMessage(NetworkMessageContainer message, Player player)
{
if (message == null)
{
ConsoleManager.WriteLine("Invalid chat message handled. Message is null.",
ConsoleMessageType.Error);
}
var messageData = message.MessageData as MessageChatMessage;
var chatMessageData = messageData.ChatMessageData;
if (player == null)
{
ConsoleManager.WriteLine("Player connection not found while handling chat message.",
ConsoleMessageType.Warning);
return;
}
var outboundChats = await _chatCommandHandler.FetchOutboundChats(player, chatMessageData.ChatJson);
if (outboundChats == null || outboundChats.Count == 0)
{
return;
}
SendChatList(outboundChats);
}
void _slaveConnected(object sender, NetworkMessageContainer messageData)
{
var data = messageData.MessageData as MessageSlaveConnectionRequest;
var response = new MessageSlaveConnectionResponse();
response.SlaveID = data.SlaveID;
if (!_slaveServers.ContainsKey(data.SlaveID))
{
SlaveServer s = new SlaveServer(data.SlaveID);
_slaveServers.Add(s.ID, s);
response.IsSuccessful = true;
_pendingRebalance = true;
_rebalanceWaitStartTime = TimeKeeper.MsSinceInitialization;
}
else
{
response.IsSuccessful = false;
}
NetworkMessageContainer msg = new NetworkMessageContainer();
msg.MessageData = response;
msg.MessageType = MessageTypes.Redis_SlaveConnectionResponse;
_redisServer.PublishObject(MessageTypes.Redis_SlaveConnectionResponse, msg);
}
public void SendMessage(NetworkMessageContainer message)
{
var msg = _messageCreatorService.CreateMessage();
message.WriteToLidgrenMessage_ToClient(message.MessageType, msg);
Connection.SendMessage(msg, NetDeliveryMethod.ReliableUnordered, 0);//TODO: implement probably static method to get sequence channel and delivery method from message type
}
private void _handleMessageIDResponse(object sender, NetworkMessageContainer messageData)
{
var data = messageData?.MessageData as MessageIDResponse;
if (data.SlaveServerID != _mySlaveID)
{
return;
}
else
{
switch (data.IDType)
{
case IDTypes.GalaxyID:
_galaxyIDManager.ReceiveServerIDs(data.IDs);
break;
case IDTypes.TeamID:
_teamIDManager.ReceiveServerIDs(data.IDs);
break;
case IDTypes.AccountID:
_accountIdManager.ReceiveServerIDs(data.IDs);
break;
case IDTypes.TransactionID:
_transactionIdManager.ReceiveServerIDs(data.IDs);
break;
default:
throw new NotImplementedException();
break;
}
}
}
private void DrawablePortStateManager_ProcessMessage(object sender, NetworkMessageContainer message)
{
switch (message.MessageType)
{
case MessageTypes.PortDockApproval:
{
Clear();
var data = message.MessageData as PortEntryData;
// TODO: Implement reading this data, though much of this is used purely in the UI.
break;
}
case MessageTypes.ClientLoginSuccess:
{
var data = message.MessageData as MessageClientLogin;
if (data == null)
{
ClientLogger.LogError("Could not deserialize MessageClientLogin: " + message.MessageData);
return;
}
_clientPlayerInfoManager.PlayerID = data.PlayerInfo.PlayerID;
_clientPlayerInfoManager.ActiveShipID = data.PlayerInfo.ActiveShipID;
break;
}
}
}
void HandleSimulatorNetworkMessage(object sender, NetworkMessageContainer message)
{
if (message.MessageType == MessageTypes.Redis_SimulatorConnectionResponse)
{
_connectedToServer = true;
ConsoleManager.WriteLine("Connected to server.", ConsoleMessageType.NetworkMessage);
}
}
private void WarpPlayerToArea(PlayerModel player, int newAreaId)
{
var msg = new NetworkMessageContainer();
msg.MessageType = MessageTypes.Redis_AdminWarpPlayer;
msg.MessageData = new MessageAdminWarpPlayerRequest(player.ActiveShipId.Value, player.CurrentAreaID.Value, newAreaId);
_redisServer.PublishObject(MessageTypes.Redis_AdminWarpPlayer, msg);
}
void SendChatToPlayer(Player player, string chatJson, string meta)
{
var message = new NetworkMessageContainer();
message.MessageData = CreateChatMessageContainer(chatJson, meta);
message.MessageType = MessageTypes.ChatMessage;
player.SendMessage(message);
}
void _loginStateManager_MessageReceived(object sender, NetworkMessageContainer e)
{
switch (e.MessageType)
{
case MessageTypes.ClientLoginFailed:
break;
}
}
/// <summary>
/// Handles redis request for login data.
/// </summary>
private void _handleLoginDataRequest(object sender, NetworkMessageContainer messageData)
{
var req = messageData?.MessageData as ClientLoginDataRequest;
if (!_galaxyManager.IsLocalSystem(req.LastSystemID))
{
return;
}
_handleLoginDataRequestAsync(req);
}
public void SendMessageToServer(NetworkMessageContainer message)
{
#if ADMIN
if (Debugging.DisableNetworking)
{
return;
}
#endif
_redisServer.PublishObject(ChannelTypes.SimulatorToServer_Data, AreaID, message);
}
/// <summary>
/// Generates an ID and publishes a connection request to redis
/// </summary>
void _connectToServer()
{
_awaitingConnectionResponse = true;
NetworkMessageContainer msg = new NetworkMessageContainer();
msg.MessageData = new MessageSlaveConnectionRequest()
{
SlaveID = SlaveID.Value
};
msg.MessageType = MessageTypes.Redis_SlaveConnectionRequest;
_redisServer.PublishObject(MessageTypes.Redis_SlaveConnectionRequest, msg);
}
private void _handleHandoff(object sender, NetworkMessageContainer messageData)
{
MessageClientHandoff c = messageData?.MessageData as MessageClientHandoff;
if (_galaxyManager.IsLocalArea(c.DestinationAreaID))
{
ConsoleManager.WriteLine("Received client handoff");
Account refreshedAccount = _accountManager.GetAccountAsync(c.AccountID, true, true).Result;
_connectionManager.AddPendingHandoff(c.IPAddress, refreshedAccount, c.DestinationAreaID, c.ShipID, c.ServerGameStateId);
}
}
public void RequestFreeIDs(int numToRequest, IDTypes IdType)
{
//Go through redis, regardless of whether this instance is the master server
var request = new MessageIDRequest()
{
IDType = IdType, RequestingServerID = SlaveID.Value, NumIDsRequested = numToRequest
};
var msg = new NetworkMessageContainer();
msg.MessageType = MessageTypes.Redis_IDRequest;
msg.MessageData = request;
_redisServer.PublishObject(MessageTypes.Redis_IDRequest, msg);
}
public void SendMessageToServer(NetworkMessageContainer message)
{
#if ADMIN
if (Debugging.DisableNetworking)
{
return;
}
#endif
NetOutgoingMessage msg = _clientManager.Client.CreateMessage();
message.WriteToLidgrenMessage_ToServer(message.MessageType, msg);
_clientManager.Client.SendMessage(msg, _clientManager.CurrentSlaveConnection, NetDeliveryMethod.ReliableUnordered);//TODO: Implement GetNetDeliveryMethod method
}
void DrawableColonyStateManager_ProcessMessage(object sender, NetworkMessageContainer message)
{
switch (message.MessageType)
{
case MessageTypes.ClientLoginSuccess:
{
var data = message.MessageData as MessageClientLogin;
_clientPlayerInfoManager.PlayerID = data.PlayerInfo.PlayerID;
_clientPlayerInfoManager.ActiveShipID = data.PlayerInfo.ActiveShipID;
break;
}
}
}
private void _handleAdminWarpPlayer(object sender, NetworkMessageContainer messageData)
{
var request = messageData?.MessageData as MessageAdminWarpPlayerRequest;
var currentArea = _galaxyManager.GetArea(request.CurrentAreaId);
// If this is true, our server doesn't own the client.
if (currentArea?.AreaType == AreaTypes.Limbo)
{
return;
}
_handleAdminWarpPlayerAsync(request);
}
void _handleSimulatorMessage(object sender, NetworkMessageContainer message)
{
if (message.MessageType == MessageTypes.Redis_SimulatorConnectionRequest)
{
var data = message.MessageData as MessageSimulatorConnectionRequest;
IsConnected = true;
var response = new MessageSimulatorConnectionResponse()
{
SimulatorID = SimulatorID
};
_redisServer.PublishObject(ChannelTypes.ServerToSimulator_Network, SimulatorID, new NetworkMessageContainer(response, MessageTypes.Redis_SlaveConnectionResponse));
ConsoleManager.WriteLine("Simulator spawn complete, ID " + data.SimulatorID, ConsoleMessageType.Startup);
}
}
private void _handleRedisLoginDataResponse(object sender, NetworkMessageContainer messageData)
{
var res = messageData.MessageData as MessageRedisLoginDataResponse;
if (_IDToConnectionAddress.ContainsKey(res.AccountID))
{
Console.WriteLine("Error: Redis received multiple ClientLoginDataReponse objects");
}
//TODO:Figure out why this happens. If a player logs in more than once without restarting the server, this error state occurs.
else
{
_IDToConnectionAddress.TryAdd(res.AccountID, res);
}
}
protected override void _playableStateManager_MessageReceived(object sender, NetworkMessageContainer e)
{
base._playableStateManager_MessageReceived(sender, e);
switch (e.MessageType)
{
case MessageTypes.PlanetLandApproval:
{
var data = e.MessageData as PlanetEntryData;
if (data == null)
{
ClientLogger.LogError("Could not deserialize PlanetEntryData: " + e.MessageData);
return;
}
ReadIncomingPlanet(data);
_targetingService.RegisterObject(_clientShipManager.PlayerShip);
break;
}
case MessageTypes.ColonyCaptured:
{
var data = e.MessageData as MessageColonyCaptured;
if (data == null)
{
ClientLogger.LogError("Could not deserialize MessageColonyCaptured: " + e.MessageData);
return;
}
ColonyCaptured(data);
break;
}
case MessageTypes.ColonizeRequestApproval:
{
var data = e.MessageData as MessageColonizeRequestApproval;
if (data == null)
{
ClientLogger.LogError("Could not deserialize MessageColonizeRequestApproval: " + e.MessageData);
return;
}
ColonizeRequestApproval(data);
break;
}
}
}
public void SendChatToServer(string chat)
{
var msg = _clientManager.Client.CreateMessage();
var container = new NetworkMessageContainer();
var data = new MessageChatMessage();
data.ChatMessageData = new ChatMessageData(chat);
container.MessageType = MessageTypes.ChatMessage;
container.MessageData = data;
container.WriteToLidgrenMessage_ToServer(MessageTypes.ChatMessage, msg);
_clientManager.Client.SendMessage(msg, _clientManager.CurrentSlaveConnection, NetDeliveryMethod.ReliableOrdered);
}
private void _handleMessageStartUpdatingSystems(object sender, NetworkMessageContainer messageData)
{
var data = messageData?.MessageData as MessageStartUpdatingSystems;
// Return if this isn't the target slave
if (data.SlaveServerID != _mySlaveID)
{
return;
}
PSystemsLoaded = false;
if (data.ClearCurrentSystems)
{
_galaxyManager.ClearLocalSystems();
}
#if DEBUG
Stopwatch s1 = new Stopwatch();
s1.Start();
#endif
var loadedSystemModels = _databaseManager.GetAreasAsync(data.IDsToSimulate).Result;
foreach (PSystemModel p in loadedSystemModels)
{
PSystem s = Deserializer.DeserializePSystemAsync(p, _redisServer, _locatorService, _registrationManager, _databaseManager).Result;
}
foreach (var a in _galaxyManager.AllAreas)
{
//Clear existing subscriptions to prevent doubles (for hot loading)
_redisServer.UnSubscribe(ChannelTypes.WebToSlave, a.Value.Id, _routedMessageProcessor);
//Subscribe
_redisServer.Subscribe(ChannelTypes.WebToSlave, a.Value.Id, _routedMessageProcessor);
}
#if DEBUG
ConsoleManager.WriteLine(_galaxyManager.AllAreas.Count.ToString() + " total areas currently loaded.", ConsoleMessageType.Debug);
s1.Stop();
ConsoleManager.WriteLine(s1.ElapsedMilliseconds + " ms to load " + _galaxyManager.Systems.Count + " systems.", ConsoleMessageType.Debug);
#endif
PSystemsLoaded = true;
}
/// <summary>
/// Call this to begin changing area when handing off a local client.
/// </summary>
/// <param name="newArea"></param>
/// <param name="ship"></param>
/// <param name="isWarping"></param>
async Task HandoffInitiateAreaChange(int destinationAreaID, AreaTypes newAreaType, IShip ship, Player warpingPlayer)
{
var shipSaveTask = _databaseManager.SaveAsync(warpingPlayer);
var playerSaveTask = _databaseManager.SaveAsync(ship);
var shipSaveHandoffTask = _databaseManager.HandoffSaveAsync(ship);//If these collections aren't empty on server startup, a server crashed mid handoff and there could be ships/players which aren't stored in any area and might not be loaded.
var playerSaveHandoffTask = _databaseManager.HandoffSaveAsync(warpingPlayer);
//Ensure that db versions of ship and player are most recent, since they'll be loaded by slave
List <Task> tasklist = new List <Task>
{
shipSaveTask,
shipSaveHandoffTask,
playerSaveTask,
playerSaveHandoffTask,
};
await Task.WhenAll(tasklist);
if (!(shipSaveTask.Result.IsAcknowledged && shipSaveHandoffTask.Result.IsAcknowledged && playerSaveTask.Result.IsAcknowledged && playerSaveHandoffTask.Result.IsAcknowledged))
{
throw new InvalidOperationException("Error: db write failed during handoff, handoff aborted.");
}
//Send handoff to be handled by server
NetworkMessageContainer redismsg = new NetworkMessageContainer(new MessageClientHandoff((int)warpingPlayer.AccountID, (int)warpingPlayer.ActiveShipId, destinationAreaID, ((LidgrenOutgoingMessageService)warpingPlayer.MessageService).Connection.RemoteEndPoint.Address.GetAddressBytes()), MessageTypes.Redis_ClientHandoff);
_redisServer.PublishObject(MessageTypes.Redis_ClientHandoff, redismsg);
IArea currentArea = null;
if (ship.CurrentAreaId != null)
{
currentArea = _areaLocator.GetArea((int)ship.CurrentAreaId);
}
OnAreaExit(ship, currentArea, newAreaType);
currentArea.RemovePlayer(ship.GetPlayer()); //There doesn't seem to be a convenient way to avoid putting this here
currentArea.RemoveShip(ship); //Sends removeship Command to clients in area
ConsoleManager.WriteLine("Initiated Handoff");
ship.GetPlayer().IsHandedOff = true;
_registrationManager.DeRegisterObject(warpingPlayer);
_registrationManager.DeRegisterObject(ship);
_accountManager.DeregisterAccount(warpingPlayer.GetAccount());
}
void _handleIDRequest(object sender, NetworkMessageContainer messageData)
{
var data = messageData.MessageData as MessageIDRequest;
if (GlobalIDManagers.ContainsKey(data.IDType))
{
var response = new MessageIDResponse();
response.IDs = GlobalIDManagers[data.IDType].GetFreeIDs(data.NumIDsRequested);
response.SlaveServerID = data.RequestingServerID;
response.IDType = data.IDType;
NetworkMessageContainer msg = new NetworkMessageContainer();
msg.MessageData = response;
msg.MessageType = MessageTypes.Redis_IDResponse;
_redisServer.PublishObject(MessageTypes.Redis_IDResponse, msg);
}
}