void ClientManager::SendMessageToClient(Message* message)
{
// We're headed to the client, don't use the routing header.
message->setRouted(false);
// Find our client from the accountId.
boost::recursive_mutex::scoped_lock lk(mServiceMutex);
PlayerClientMap::iterator iter = mPlayerClientMap.find(message->getAccountId());
// If we found the client, send the data.
if (iter != mPlayerClientMap.end())
{
ConnectionClient* client = (*iter).second;
//unlock here sendchannel is getting the mSessionMutex we dont want to spend time waiting to synchronize mutexes
lk.unlock();
client->SendChannelA(message, message->getPriority(), message->getFastpath());
}
else
{
//happens when the client logs out
gMessageFactory->DestroyMessage(message);
}
}
//======================================================================================================================
void ClientManager::handleDatabaseJobComplete(void* ref, DatabaseResult* result)
{
// This assumes only authentication calls are async right now. Will change as needed.
ConnectionClient* client = reinterpret_cast<ConnectionClient*>(ref);
switch (client->getState())
{
case CCSTATE_QueryAuth:
{
_handleQueryAuth(client, result);
break;
}
case CCSTATE_AllowedChars:
{
struct charsCurrentAllowed {
uint32 currentChars;
uint32 charsAllowed;
} charsStruct;
DataBinding* binding = mDatabase->createDataBinding(2);
binding->addField(DFT_int32,offsetof(charsCurrentAllowed, currentChars), 4, 0);
binding->addField(DFT_int32,offsetof(charsCurrentAllowed, charsAllowed), 4, 1);
result->getNextRow(binding,&charsStruct);
client->setCharsAllowed(charsStruct.charsAllowed);
client->setCurrentChars(charsStruct.currentChars);
client->setState(CCSTATE_QueryAuth);
mDatabase->destroyDataBinding(binding);
break;
}
default:
break;
}
}
NetworkClient* ServerManager::handleSessionConnect(Session* session, Service* service)
{
NetworkClient* newClient = 0;
ServerAddress serverAddress;
// Execute our statement
int8 sql[500];
sprintf(sql,"SELECT id, address, port, status, active FROM config_process_list WHERE address='%s' AND port=%u;", session->getAddressString(), session->getPortHost());
DatabaseResult* result = mDatabase->ExecuteSynchSql(sql);
// If we found them
if(result->getRowCount() == 1)
{
// Retrieve our routes and add them to the map.
result->GetNextRow(mServerBinding,&serverAddress);
// put this fresh data in our list.
newClient = new ConnectionClient();
ConnectionClient* connClient = reinterpret_cast<ConnectionClient*>(newClient);
ConnectionClient* oldClient = mServerAddressMap[serverAddress.mId].mConnectionClient;
if(oldClient)
{
delete(oldClient);
--mTotalConnectedServers;
}
connClient->setServerId(serverAddress.mId);
memcpy(&mServerAddressMap[serverAddress.mId], &serverAddress, sizeof(ServerAddress));
mServerAddressMap[serverAddress.mId].mConnectionClient = connClient;
gLogger->log(LogManager::DEBUG,"*** Backend server connected id: %u\n",mServerAddressMap[serverAddress.mId].mId);
// If this is one of the servers we're waiting for, then update our count
if(mServerAddressMap[serverAddress.mId].mActive)
{
++mTotalConnectedServers;
if(mTotalConnectedServers == mTotalActiveServers)
{
mDatabase->ExecuteProcedureAsync(0, 0, "CALL sp_GalaxyStatusUpdate(%u, %u);", 2, mClusterId); // Set status to online
}
}
}
else
{
gLogger->log(LogManager::CRITICAL,"*** Backend server connect error - Server not found in DB\n");
gLogger->log(LogManager::DEBUG,sql);
gLogger->log(LogManager::DEBUG,"\n");
}
// Delete our DB objects.
mDatabase->DestroyResult(result);
return(newClient);
}
void ClientManager::handleSessionMessage(NetworkClient* client, Message* message)
{
ConnectionClient* connClient = reinterpret_cast<ConnectionClient*>(client);
// Assign our account info to this message, then route it.
message->setAccountId(connClient->getAccountId());
// Dispatch this message to the router
mMessageRouter->RouteMessage(message, connClient);
}
void ServerManager::handleSessionDisconnect(NetworkClient* client)
{
ConnectionClient* connClient = reinterpret_cast<ConnectionClient*>(client);
// Server disconnected. But don't remove the mapping if it's not the same one.
if(mServerAddressMap[connClient->getServerId()].mConnectionClient == connClient)
{
//its undefined later
uint32 id = connClient->getServerId();
//we actually delete the client in line 186 with delete(client)
//deleting it here just crashes us everytime a server disconnects :)
//delete mServerAddressMap[id].mConnectionClient;
mServerAddressMap[id].mConnectionClient = 0;
}
// update the galaxy state
if(mServerAddressMap[connClient->getServerId()].mActive)
{
--mTotalConnectedServers;
mDatabase->ExecuteProcedureAsync(0, 0, "CALL sp_GalaxyStatusUpdate(%u, %u);", 1, mClusterId); // Set status to online
}
gLogger->log(LogManager::DEBUG,"Servermanager handle server down\n");
mClientManager->handleServerDown(connClient->getServerId());
connClient->getSession()->setStatus(SSTAT_Destroy);
connClient->getSession()->getService()->AddSessionToProcessQueue(connClient->getSession());
delete(client);
}
void ClientManager::handleSessionDisconnect(NetworkClient* client)
{
Message* message;
ConnectionClient* connClient = reinterpret_cast<ConnectionClient*>(client);
// Create a ClusterClientDisconnect message and send it to the servers
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opClusterClientDisconnect);
gMessageFactory->addUint32(0); // Reason: Disconnected
message = gMessageFactory->EndMessage();
message->setAccountId(connClient->getAccountId());
message->setDestinationId(CR_Chat); // chat server
message->setRouted(true);
mMessageRouter->RouteMessage(message, connClient);
// Create a ClusterClientDisconnect message and send it to the servers
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opClusterClientDisconnect);
gMessageFactory->addUint32(0); // Reason: Disconnected
message = gMessageFactory->EndMessage();
message->setAccountId(connClient->getAccountId());
message->setDestinationId(static_cast<uint8>(connClient->getServerId())); // zone server
message->setRouted(true);
mMessageRouter->RouteMessage(message, connClient);
// Update the account record that the account is logged out.
mDatabase->executeProcedureAsync(0, 0, "CALL %s.sp_AccountStatusUpdate(%u, %u);",mDatabase->galaxy(), 0, connClient->getAccountId());
// Client has disconnected.
boost::recursive_mutex::scoped_lock lk(mServiceMutex);
PlayerClientMap::iterator iter = mPlayerClientMap.find(connClient->getAccountId());
if(iter != mPlayerClientMap.end())
{
delete ((*iter).second);
mPlayerClientMap.erase(iter);
}
}
void ClientManager::handleServerDown(uint32 serverId)
{
// disconnect all clients that were on this server, if its a zone
if(serverId >= 8)
{
boost::recursive_mutex::scoped_lock lk(mServiceMutex);
PlayerClientMap::iterator it = mPlayerClientMap.begin();
while(it != mPlayerClientMap.end())
{
ConnectionClient* client = (*it).second;
if(client->getServerId() == serverId)
{
client->Disconnect(0);
}
++it;
}
}
}
//======================================================================================================================
void ClientManager::_processClusterZoneTransferCharacter(ConnectionClient* client, Message* message)
{
uint64 characterId = message->getUint64();
uint32 newPlanetId = message->getUint32();
uint32 oldServerId = 0;
// Update our client
boost::recursive_mutex::scoped_lock lk(mServiceMutex);
PlayerClientMap::iterator iter;
iter = mPlayerClientMap.find(message->getAccountId());
if (iter != mPlayerClientMap.end())
{
ConnectionClient* connClient = (*iter).second;
oldServerId = connClient->getServerId();
connClient->setServerId(newPlanetId + 8);
// send an opClusterClientDisconnnect message to the old zone server.
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opClusterClientDisconnect);
gMessageFactory->addUint32(1); // Reason: Zone transfer
Message* oldZoneMessage = gMessageFactory->EndMessage();
// This one goes to
oldZoneMessage->setAccountId(connClient->getAccountId());
oldZoneMessage->setDestinationId(static_cast<uint8>(oldServerId)); // zoneIds are planetIds + 8
oldZoneMessage->setRouted(true);
mMessageRouter->RouteMessage(oldZoneMessage, client);
// send an opClusterClientConnect message to the new zone server.
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opClusterClientConnect);
Message* newZoneMessage = gMessageFactory->EndMessage();
// This one goes to
newZoneMessage->setAccountId(connClient->getAccountId());
newZoneMessage->setDestinationId(static_cast<uint8>(newPlanetId + 8)); // zoneIds are planetIds + 8
newZoneMessage->setRouted(true);
mMessageRouter->RouteMessage(newZoneMessage, client);
// send an opSelectCharacter message to the new zone server.
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opSelectCharacter);
gMessageFactory->addUint64(characterId);
newZoneMessage = gMessageFactory->EndMessage();
// This one goes to
newZoneMessage->setAccountId(connClient->getAccountId());
newZoneMessage->setDestinationId(static_cast<uint8>(newPlanetId + 8)); // zoneIds are planetIds + 8
newZoneMessage->setRouted(true);
mMessageRouter->RouteMessage(newZoneMessage, client);
// notify the chatserver
gMessageFactory->StartMessage();
gMessageFactory->addUint32(opClusterZoneTransferCharacter);
gMessageFactory->addUint32(newPlanetId);
newZoneMessage = gMessageFactory->EndMessage();
newZoneMessage->setAccountId(message->getAccountId());
newZoneMessage->setDestinationId(CR_Chat);
newZoneMessage->setRouted(true);
mMessageRouter->RouteMessage(newZoneMessage,client);
}
else
{
// client may have disconnected right in the middle of the transfer
LOG(warning) << "Client not found during zone transfer.\n";
}
}
