src/mangosd/Master.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 /** \file
  20     \ingroup mangosd
  21 */
  22
  23 #include <ace/OS_NS_signal.h>
  24
  25 #include "WorldSocketMgr.h"
  26 #include "Common.h"
  27 #include "Master.h"
  28 #include "WorldSocket.h"
  29 #include "WorldRunnable.h"
  30 #include "World.h"
  31 #include "Log.h"
  32 #include "Timer.h"
  33 #include "Policies/SingletonImp.h"
  34 #include "SystemConfig.h"
  35 #include "Config/ConfigEnv.h"
  36 #include "Database/DatabaseEnv.h"
  37 #include "CliRunnable.h"
  38 #include "RASocket.h"
  39 #include "ScriptCalls.h"
  40 #include "Util.h"
  41 #include "revision_sql.h"
  42
  43 #include "sockets/TcpSocket.h"
  44 #include "sockets/Utility.h"
  45 #include "sockets/Parse.h"
  46 #include "sockets/Socket.h"
  47 #include "sockets/SocketHandler.h"
  48 #include "sockets/ListenSocket.h"
  49
  50 #ifdef WIN32
  51 #include "ServiceWin32.h"
  52 extern int m_ServiceStatus;
  53 #endif
  54
  55 /// \todo Warning disabling not useful under VC++2005. Can somebody say on which compiler it is useful?
  56 #pragma warning(disable:4305)
  57
  58 INSTANTIATE_SINGLETON_1( Master );
  59
  60 volatile uint32 Master::m_masterLoopCounter = 0;
  61
  62 class FreezeDetectorRunnable : public ACE_Based::Runnable
  63 {
  64 public:
  65     FreezeDetectorRunnable() { _delaytime = 0; }
  66     uint32 m_loops, m_lastchange;
  67     uint32 w_loops, w_lastchange;
  68     uint32 _delaytime;
  69     void SetDelayTime(uint32 t) { _delaytime = t; }
  70     void run(void)
  71     {
  72         if(!_delaytime)
  73             return;
  74         sLog.outString("Starting up anti-freeze thread (%u seconds max stuck time)...",_delaytime/1000);
  75         m_loops = 0;
  76         w_loops = 0;
  77         m_lastchange = 0;
  78         w_lastchange = 0;
  79         while(!World::IsStopped())
  80         {
  81             ACE_Based::Thread::Sleep(1000);
  82
  83             uint32 curtime = getMSTime();
  84             //DEBUG_LOG("anti-freeze: time=%u, counters=[%u; %u]",curtime,Master::m_masterLoopCounter,World::m_worldLoopCounter);
  85
  86             // There is no Master anymore
  87             // TODO: clear the rest of the code
  88 //            // normal work
  89 //            if(m_loops != Master::m_masterLoopCounter)
  90 //            {
  91 //                m_lastchange = curtime;
  92 //                m_loops = Master::m_masterLoopCounter;
  93 //            }
  94 //            // possible freeze
  95 //            else if(getMSTimeDiff(m_lastchange,curtime) > _delaytime)
  96 //            {
  97 //                sLog.outError("Main/Sockets Thread hangs, kicking out server!");
  98 //                *((uint32 volatile*)NULL) = 0;                       // bang crash
  99 //            }
 100
 101             // normal work
 102             if(w_loops != World::m_worldLoopCounter)
 103             {
 104                 w_lastchange = curtime;
 105                 w_loops = World::m_worldLoopCounter;
 106             }
 107             // possible freeze
 108             else if(getMSTimeDiff(w_lastchange,curtime) > _delaytime)
 109             {
 110                 sLog.outError("World Thread hangs, kicking out server!");
 111                 *((uint32 volatile*)NULL) = 0;                       // bang crash
 112             }
 113         }
 114         sLog.outString("Anti-freeze thread exiting without problems.");
 115     }
 116 };
 117
 118 class RARunnable : public ACE_Based::Runnable
 119 {
 120 public:
 121     uint32 numLoops, loopCounter;
 122
 123     RARunnable ()
 124     {
 125         uint32 socketSelecttime = sWorld.getConfig (CONFIG_SOCKET_SELECTTIME);
 126         numLoops = (sConfig.GetIntDefault ("MaxPingTime", 30) * (MINUTE * 1000000 / socketSelecttime));
 127         loopCounter = 0;
 128     }
 129
 130     void checkping ()
 131     {
 132         // ping if need
 133         if ((++loopCounter) == numLoops)
 134         {
 135             loopCounter = 0;
 136             sLog.outDetail ("Ping MySQL to keep connection alive");
 137             delete WorldDatabase.Query ("SELECT 1 FROM command LIMIT 1");
 138             delete loginDatabase.Query ("SELECT 1 FROM realmlist LIMIT 1");
 139             delete CharacterDatabase.Query ("SELECT 1 FROM bugreport LIMIT 1");
 140         }
 141     }
 142
 143     void run ()
 144     {
 145         SocketHandler h;
 146
 147         // Launch the RA listener socket
 148         ListenSocket<RASocket> RAListenSocket (h);
 149         bool usera = sConfig.GetBoolDefault ("Ra.Enable", false);
 150
 151         if (usera)
 152         {
 153             port_t raport = sConfig.GetIntDefault ("Ra.Port", 3443);
 154             std::string stringip = sConfig.GetStringDefault ("Ra.IP", "0.0.0.0");
 155             ipaddr_t raip;
 156             if (!Utility::u2ip (stringip, raip))
 157                 sLog.outError ("MaNGOS RA can not bind to ip %s", stringip.c_str ());
 158             else if (RAListenSocket.Bind (raip, raport))
 159                 sLog.outError ("MaNGOS RA can not bind to port %d on %s", raport, stringip.c_str ());
 160             else
 161             {
 162                 h.Add (&RAListenSocket);
 163
 164                 sLog.outString ("Starting Remote access listner on port %d on %s", raport, stringip.c_str ());
 165             }
 166         }
 167
 168         // Socket Selet time is in microseconds , not miliseconds!!
 169         uint32 socketSelecttime = sWorld.getConfig (CONFIG_SOCKET_SELECTTIME);
 170
 171         // if use ra spend time waiting for io, if not use ra ,just sleep
 172         if (usera)
 173         {
 174             while (!World::IsStopped())
 175             {
 176                 h.Select (0, socketSelecttime);
 177                 checkping ();
 178             }
 179         }
 180         else
 181         {
 182             while (!World::IsStopped())
 183             {
 184                 ACE_Based::Thread::Sleep(static_cast<unsigned long> (socketSelecttime / 1000));
 185                 checkping ();
 186             }
 187         }
 188     }
 189 };
 190
 191 Master::Master()
 192 {
 193 }
 194
 195 Master::~Master()
 196 {
 197 }
 198
 199 /// Main function
 200 int Master::Run()
 201 {
 202     /// worldd PID file creation
 203     std::string pidfile = sConfig.GetStringDefault("PidFile", "");
 204     if(!pidfile.empty())
 205     {
 206         uint32 pid = CreatePIDFile(pidfile);
 207         if( !pid )
 208         {
 209             sLog.outError( "Cannot create PID file %s.\n", pidfile.c_str() );
 210             return 1;
 211         }
 212
 213         sLog.outString( "Daemon PID: %u\n", pid );
 214     }
 215
 216     ///- Start the databases
 217     if (!_StartDB())
 218         return 1;
 219
 220     ///- Initialize the World
 221     sWorld.SetInitialWorldSettings();
 222
 223     ///- Catch termination signals
 224     _HookSignals();
 225
 226     ///- Launch WorldRunnable thread
 227     ACE_Based::Thread world_thread(new WorldRunnable);
 228     world_thread.setPriority(ACE_Based::Highest);
 229
 230     // set server online
 231     loginDatabase.PExecute("UPDATE realmlist SET color = 0, population = 0 WHERE id = '%d'",realmID);
 232
 233     ACE_Based::Thread* cliThread = NULL;
 234
 235 #ifdef WIN32
 236     if (sConfig.GetBoolDefault("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/)
 237 #else
 238     if (sConfig.GetBoolDefault("Console.Enable", true))
 239 #endif
 240     {
 241         ///- Launch CliRunnable thread
 242         cliThread = new ACE_Based::Thread(new CliRunnable);
 243     }
 244
 245     ACE_Based::Thread rar_thread(new RARunnable);
 246
 247     ///- Handle affinity for multiple processors and process priority on Windows
 248     #ifdef WIN32
 249     {
 250         HANDLE hProcess = GetCurrentProcess();
 251
 252         uint32 Aff = sConfig.GetIntDefault("UseProcessors", 0);
 253         if(Aff > 0)
 254         {
 255             ULONG_PTR appAff;
 256             ULONG_PTR sysAff;
 257
 258             if(GetProcessAffinityMask(hProcess,&appAff,&sysAff))
 259             {
 260                 ULONG_PTR curAff = Aff & appAff;            // remove non accessible processors
 261
 262                 if(!curAff )
 263                 {
 264                     sLog.outError("Processors marked in UseProcessors bitmask (hex) %x not accessible for mangosd. Accessible processors bitmask (hex): %x",Aff,appAff);
 265                 }
 266                 else
 267                 {
 268                     if(SetProcessAffinityMask(hProcess,curAff))
 269                         sLog.outString("Using processors (bitmask, hex): %x", curAff);
 270                     else
 271                         sLog.outError("Can't set used processors (hex): %x",curAff);
 272                 }
 273             }
 274             sLog.outString();
 275         }
 276
 277         bool Prio = sConfig.GetBoolDefault("ProcessPriority", false);
 278
 279 //        if(Prio && (m_ServiceStatus == -1)/* need set to default process priority class in service mode*/)
 280         if(Prio)
 281         {
 282             if(SetPriorityClass(hProcess,HIGH_PRIORITY_CLASS))
 283                 sLog.outString("mangosd process priority class set to HIGH");
 284             else
 285                 sLog.outError("ERROR: Can't set mangosd process priority class.");
 286             sLog.outString();
 287         }
 288     }
 289     #endif
 290
 291     uint32 realCurrTime, realPrevTime;
 292     realCurrTime = realPrevTime = getMSTime();
 293
 294     uint32 socketSelecttime = sWorld.getConfig(CONFIG_SOCKET_SELECTTIME);
 295
 296     ///- Start up freeze catcher thread
 297     if(uint32 freeze_delay = sConfig.GetIntDefault("MaxCoreStuckTime", 0))
 298     {
 299         FreezeDetectorRunnable *fdr = new FreezeDetectorRunnable();
 300         fdr->SetDelayTime(freeze_delay*1000);
 301         ACE_Based::Thread freeze_thread(fdr);
 302         freeze_thread.setPriority(ACE_Based::Highest);
 303     }
 304
 305     ///- Launch the world listener socket
 306     port_t wsport = sWorld.getConfig (CONFIG_PORT_WORLD);
 307     std::string bind_ip = sConfig.GetStringDefault ("BindIP", "0.0.0.0");
 308
 309     if (sWorldSocketMgr->StartNetwork (wsport, bind_ip.c_str ()) == -1)
 310     {
 311         sLog.outError ("Failed to start network");
 312         World::StopNow(ERROR_EXIT_CODE);
 313         // go down and shutdown the server
 314     }
 315
 316     sWorldSocketMgr->Wait ();
 317
 318     // set server offline
 319     loginDatabase.PExecute("UPDATE realmlist SET color = 2 WHERE id = '%d'",realmID);
 320
 321     ///- Remove signal handling before leaving
 322     _UnhookSignals();
 323
 324     // when the main thread closes the singletons get unloaded
 325     // since worldrunnable uses them, it will crash if unloaded after master
 326     world_thread.wait();
 327     rar_thread.wait ();
 328
 329     ///- Clean database before leaving
 330     clearOnlineAccounts();
 331
 332     ///- Wait for delay threads to end
 333     CharacterDatabase.HaltDelayThread();
 334     WorldDatabase.HaltDelayThread();
 335     loginDatabase.HaltDelayThread();
 336
 337     sLog.outString( "Halting process..." );
 338
 339     if (cliThread)
 340     {
 341         #ifdef WIN32
 342
 343         // this only way to terminate CLI thread exist at Win32 (alt. way exist only in Windows Vista API)
 344         //_exit(1);
 345         // send keyboard input to safely unblock the CLI thread
 346         INPUT_RECORD b[5];
 347         HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
 348         b[0].EventType = KEY_EVENT;
 349         b[0].Event.KeyEvent.bKeyDown = TRUE;
 350         b[0].Event.KeyEvent.uChar.AsciiChar = 'X';
 351         b[0].Event.KeyEvent.wVirtualKeyCode = 'X';
 352         b[0].Event.KeyEvent.wRepeatCount = 1;
 353
 354         b[1].EventType = KEY_EVENT;
 355         b[1].Event.KeyEvent.bKeyDown = FALSE;
 356         b[1].Event.KeyEvent.uChar.AsciiChar = 'X';
 357         b[1].Event.KeyEvent.wVirtualKeyCode = 'X';
 358         b[1].Event.KeyEvent.wRepeatCount = 1;
 359
 360         b[2].EventType = KEY_EVENT;
 361         b[2].Event.KeyEvent.bKeyDown = TRUE;
 362         b[2].Event.KeyEvent.dwControlKeyState = 0;
 363         b[2].Event.KeyEvent.uChar.AsciiChar = '\r';
 364         b[2].Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
 365         b[2].Event.KeyEvent.wRepeatCount = 1;
 366         b[2].Event.KeyEvent.wVirtualScanCode = 0x1c;
 367
 368         b[3].EventType = KEY_EVENT;
 369         b[3].Event.KeyEvent.bKeyDown = FALSE;
 370         b[3].Event.KeyEvent.dwControlKeyState = 0;
 371         b[3].Event.KeyEvent.uChar.AsciiChar = '\r';
 372         b[3].Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
 373         b[3].Event.KeyEvent.wVirtualScanCode = 0x1c;
 374         b[3].Event.KeyEvent.wRepeatCount = 1;
 375         DWORD numb;
 376         BOOL ret = WriteConsoleInput(hStdIn, b, 4, &numb);
 377
 378         cliThread->wait();
 379
 380         #else
 381
 382         cliThread->destroy();
 383
 384         #endif
 385
 386         delete cliThread;
 387     }
 388
 389     // for some unknown reason, unloading scripts here and not in worldrunnable
 390     // fixes a memory leak related to detaching threads from the module
 391     UnloadScriptingModule();
 392
 393     // Exit the process with specified return value
 394     return World::GetExitCode();
 395 }
 396
 397 /// Initialize connection to the databases
 398 bool Master::_StartDB()
 399 {
 400     ///- Get world database info from configuration file
 401     std::string dbstring = sConfig.GetStringDefault("WorldDatabaseInfo", "");
 402     if(dbstring.empty())
 403     {
 404         sLog.outError("Database not specified in configuration file");
 405         return false;
 406     }
 407     sLog.outString("World Database: %s", dbstring.c_str());
 408
 409     ///- Initialise the world database
 410     if(!WorldDatabase.Initialize(dbstring.c_str()))
 411     {
 412         sLog.outError("Cannot connect to world database %s",dbstring.c_str());
 413         return false;
 414     }
 415
 416     if(!WorldDatabase.CheckRequiredField("db_version",REVISION_DB_MANGOS))
 417         return false;
 418
 419     dbstring = sConfig.GetStringDefault("CharacterDatabaseInfo", "");
 420     if(dbstring.empty())
 421     {
 422         sLog.outError("Character Database not specified in configuration file");
 423         return false;
 424     }
 425     sLog.outString("Character Database: %s", dbstring.c_str());
 426
 427     ///- Initialise the Character database
 428     if(!CharacterDatabase.Initialize(dbstring.c_str()))
 429     {
 430         sLog.outError("Cannot connect to Character database %s",dbstring.c_str());
 431         return false;
 432     }
 433
 434     if(!CharacterDatabase.CheckRequiredField("character_db_version",REVISION_DB_CHARACTERS))
 435         return false;
 436
 437     ///- Get login database info from configuration file
 438     dbstring = sConfig.GetStringDefault("LoginDatabaseInfo", "");
 439     if(dbstring.empty())
 440     {
 441         sLog.outError("Login database not specified in configuration file");
 442         return false;
 443     }
 444
 445     ///- Initialise the login database
 446     sLog.outString("Login Database: %s", dbstring.c_str() );
 447     if(!loginDatabase.Initialize(dbstring.c_str()))
 448     {
 449         sLog.outError("Cannot connect to login database %s",dbstring.c_str());
 450         return false;
 451     }
 452
 453     if(!loginDatabase.CheckRequiredField("realmd_db_version",REVISION_DB_REALMD))
 454         return false;
 455
 456     ///- Get the realm Id from the configuration file
 457     realmID = sConfig.GetIntDefault("RealmID", 0);
 458     if(!realmID)
 459     {
 460         sLog.outError("Realm ID not defined in configuration file");
 461         return false;
 462     }
 463
 464     sLog.outString("Realm running as realm ID %d", realmID);
 465
 466     ///- Clean the database before starting
 467     clearOnlineAccounts();
 468
 469     sWorld.LoadDBVersion();
 470
 471     sLog.outString("Using World DB: %s", sWorld.GetDBVersion());
 472     sLog.outString("Using creature EventAI: %s", sWorld.GetCreatureEventAIVersion());
 473     return true;
 474 }
 475
 476 /// Clear 'online' status for all accounts with characters in this realm
 477 void Master::clearOnlineAccounts()
 478 {
 479     // Cleanup online status for characters hosted at current realm
 480     /// \todo Only accounts with characters logged on *this* realm should have online status reset. Move the online column from 'account' to 'realmcharacters'?
 481     loginDatabase.PExecute("UPDATE account SET active_realm_id = 0 WHERE active_realm_id = '%d'", realmID);
 482
 483     CharacterDatabase.Execute("UPDATE characters SET online = 0 WHERE online<>0");
 484
 485     // Battleground instance ids reset at server restart
 486     CharacterDatabase.Execute("UPDATE character_battleground_data SET instance_id = 0");
 487 }
 488
 489 /// Handle termination signals
 490 void Master::_OnSignal(int s)
 491 {
 492     switch (s)
 493     {
 494         case SIGINT:
 495             World::StopNow(RESTART_EXIT_CODE);
 496             break;
 497         case SIGTERM:
 498         #ifdef _WIN32
 499         case SIGBREAK:
 500         #endif
 501             World::StopNow(SHUTDOWN_EXIT_CODE);
 502             break;
 503     }
 504
 505     signal(s, _OnSignal);
 506 }
 507
 508 /// Define hook '_OnSignal' for all termination signals
 509 void Master::_HookSignals()
 510 {
 511     signal(SIGINT, _OnSignal);
 512     signal(SIGTERM, _OnSignal);
 513     #ifdef _WIN32
 514     signal(SIGBREAK, _OnSignal);
 515     #endif
 516 }
 517
 518 /// Unhook the signals before leaving
 519 void Master::_UnhookSignals()
 520 {
 521     signal(SIGINT, 0);
 522     signal(SIGTERM, 0);
 523     #ifdef _WIN32
 524     signal(SIGBREAK, 0);
 525     #endif
 526 }