projects/stargazer/main.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  */
  20
  21  /*
  22  $Revision: 1.124 $
  23  $Date: 2010/10/04 20:19:12 $
  24  $Author: faust $
  25  */
  26
  27 #include <unistd.h>
  28 #include <sys/ipc.h>
  29 #include <sys/msg.h>
  30 #include <sys/types.h>
  31 #include <sys/wait.h>
  32 #include <sys/stat.h> // S_IRUSR
  33 #include <fcntl.h> // create
  34
  35 #include <csignal>
  36 #include <cerrno>
  37 #include <cstdio>
  38 #include <cstdlib> // srandom, exit
  39 #include <fstream>
  40 #include <vector>
  41 #include <set>
  42 #include <list>
  43
  44 #include "stg/user.h"
  45 #include "stg/common.h"
  46 #include "stg/plugin.h"
  47 #include "stg/logger.h"
  48 #include "stg/scriptexecuter.h"
  49 #include "stg/conffiles.h"
  50 #include "stg/version.h"
  51 #include "stg/pinger.h"
  52 #include "stg_timer.h"
  53 #include "settings_impl.h"
  54 #include "users_impl.h"
  55 #include "admins_impl.h"
  56 #include "tariffs_impl.h"
  57 #include "services_impl.h"
  58 #include "corps_impl.h"
  59 #include "traffcounter_impl.h"
  60 #include "plugin_runner.h"
  61 #include "store_loader.h"
  62 #include "pidfile.h"
  63 #include "eventloop.h"
  64
  65 using namespace std;
  66
  67 #ifdef DEBUG
  68     #define MAIN_DEBUG (1)
  69     #define NO_DAEMON  (1)
  70 #endif
  71
  72 #define START_FILE "/._ST_ART_ED_"
  73
  74 set<pid_t> executersPid;
  75
  76 //-----------------------------------------------------------------------------
  77 bool StartModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs)
  78 {
  79 return lhs.GetStartPosition() < rhs.GetStartPosition();
  80 }
  81 //-----------------------------------------------------------------------------
  82 bool StopModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs)
  83 {
  84 return lhs.GetStopPosition() > rhs.GetStopPosition();
  85 }
  86 //-----------------------------------------------------------------------------
  87 static void StartTimer()
  88 {
  89 STG_LOGGER & WriteServLog = GetStgLogger();
  90
  91 if (RunStgTimer())
  92     {
  93     WriteServLog("Cannot start timer. Fatal.");
  94     //printfd(__FILE__, "Cannot start timer. Fatal.\n");
  95     exit(1);
  96     }
  97 else
  98     {
  99     WriteServLog("Timer thread started successfully.");
 100     //printfd(__FILE__, "Timer thread started successfully.\n");
 101     }
 102 }
 103 //-----------------------------------------------------------------------------
 104 int StartScriptExecuter(char * procName, int msgKey, int * msgID, SETTINGS_IMPL * settings)
 105 {
 106 STG_LOGGER & WriteServLog = GetStgLogger();
 107
 108 if (*msgID == -11)   // If msgID == -11 - first call. Create queue
 109     {
 110     for (int i = 0; i < 2; i++)
 111         {
 112         *msgID = msgget(msgKey, IPC_CREAT | IPC_EXCL | 0600);
 113
 114         if (*msgID == -1)
 115             {
 116             *msgID = msgget(msgKey, 0);
 117             if (*msgID == -1)
 118                 {
 119                 WriteServLog("Message queue not created.");
 120                 return -1;
 121                 }
 122             else
 123                 {
 124                 msgctl(*msgID, IPC_RMID, NULL);
 125                 }
 126             }
 127         else
 128             {
 129             WriteServLog("Message queue created successfully. msgKey=%d msgID=%d", msgKey, *msgID);
 130             break;
 131             }
 132         }
 133     }
 134
 135 pid_t executerPid = fork();
 136
 137 switch (executerPid)
 138     {
 139     case -1:
 140         WriteServLog("Fork error!");
 141         return -1;
 142
 143     case 0:
 144         delete settings;
 145         Executer(*msgID, executerPid, procName);
 146         return 1;
 147
 148     default:
 149         if (executersPid.empty()) {
 150             Executer(*msgID, executerPid, NULL);
 151         }
 152         executersPid.insert(executerPid);
 153     }
 154 return 0;
 155 }
 156 //-----------------------------------------------------------------------------
 157 #ifndef NO_DAEMON
 158 int ForkAndWait(const string & confDir)
 159 #else
 160 int ForkAndWait(const string &)
 161 #endif
 162 {
 163 #ifndef NO_DAEMON
 164 stgChildPid = fork();
 165 string startFile = confDir + START_FILE;
 166 unlink(startFile.c_str());
 167
 168 switch (stgChildPid)
 169     {
 170     case -1:
 171         return -1;
 172         break;
 173
 174     case 0:
 175         close(1);
 176         close(2);
 177         setsid();
 178         break;
 179
 180     default:
 181         struct timespec ts = {0, 200000000};
 182         for (int i = 0; i < 120 * 5; i++)
 183             {
 184             if (access(startFile.c_str(), F_OK) == 0)
 185                 {
 186                 unlink(startFile.c_str());
 187                 exit(0);
 188                 }
 189
 190             nanosleep(&ts, NULL);
 191             }
 192         unlink(startFile.c_str());
 193         exit(1);
 194         break;
 195     }
 196 #endif
 197 return 0;
 198 }
 199 //-----------------------------------------------------------------------------
 200 void KillExecuters()
 201 {
 202 set<pid_t>::iterator pid;
 203 pid = executersPid.begin();
 204 while (pid != executersPid.end())
 205     {
 206     printfd(__FILE__, "KillExecuters pid=%d\n", *pid);
 207     kill(*pid, SIGUSR1);
 208     ++pid;
 209     }
 210 }
 211 //-----------------------------------------------------------------------------
 212 int main(int argc, char * argv[])
 213 {
 214 SETTINGS_IMPL * settings = NULL;
 215 STORE * dataStore = NULL;
 216 TARIFFS_IMPL * tariffs = NULL;
 217 ADMINS_IMPL * admins = NULL;
 218 USERS_IMPL * users = NULL;
 219 TRAFFCOUNTER_IMPL * traffCnt = NULL;
 220 SERVICES_IMPL * services = NULL;
 221 CORPORATIONS_IMPL * corps = NULL;
 222 int msgID = -11;
 223
 224     {
 225     STG_LOGGER & WriteServLog = GetStgLogger();
 226     WriteServLog.SetLogFileName("/var/log/stargazer.log");
 227     }
 228
 229 vector<MODULE_SETTINGS> modSettings;
 230 list<PLUGIN_RUNNER> modules;
 231
 232 list<PLUGIN_RUNNER>::iterator modIter;
 233
 234 if (getuid())
 235     {
 236     printf("You must be root. Exit.\n");
 237     exit(1);
 238     }
 239
 240 if (argc == 2)
 241     settings = new SETTINGS_IMPL(argv[1]);
 242 else
 243     settings = new SETTINGS_IMPL();
 244
 245 if (settings->ReadSettings())
 246     {
 247     STG_LOGGER & WriteServLog = GetStgLogger();
 248
 249     if (settings->GetLogFileName() != "")
 250         WriteServLog.SetLogFileName(settings->GetLogFileName());
 251
 252     WriteServLog("ReadSettings error. %s", settings->GetStrError().c_str());
 253     exit(1);
 254     }
 255
 256 #ifndef NO_DAEMON
 257 string startFile(settings->GetConfDir() + START_FILE);
 258 #endif
 259
 260 if (ForkAndWait(settings->GetConfDir()) < 0)
 261     {
 262     STG_LOGGER & WriteServLog = GetStgLogger();
 263     WriteServLog("Fork error!");
 264     exit(1);
 265     }
 266
 267 STG_LOGGER & WriteServLog = GetStgLogger();
 268 WriteServLog.SetLogFileName(settings->GetLogFileName());
 269 WriteServLog("Stg v. %s", SERVER_VERSION);
 270
 271 for (size_t i = 0; i < settings->GetExecutersNum(); i++)
 272     {
 273     int ret = StartScriptExecuter(argv[0], settings->GetExecMsgKey(), &msgID, settings);
 274     if (ret < 0)
 275         {
 276         STG_LOGGER & WriteServLog = GetStgLogger();
 277         WriteServLog("Start Script Executer error!");
 278         return 1;
 279         }
 280     if (ret == 1)
 281         {
 282         // Stopping child
 283         return 0;
 284         }
 285     }
 286
 287 PIDFile pidFile(settings->GetPIDFileName());
 288
 289 StartTimer();
 290 WaitTimer();
 291 if (!IsStgTimerRunning())
 292     {
 293     printfd(__FILE__, "Timer thread not started in 1 sec!\n");
 294     WriteServLog("Timer thread not started in 1 sec!");
 295     }
 296
 297 EVENT_LOOP & loop(EVENT_LOOP_SINGLETON::GetInstance());
 298
 299 STORE_LOADER storeLoader(*settings);
 300 if (storeLoader.Load())
 301     {
 302     WriteServLog("Storage plugin: '%s'", storeLoader.GetStrError().c_str());
 303     goto exitLblNotStarted;
 304     }
 305
 306 if (loop.Start())
 307     {
 308     WriteServLog("Event loop not started.");
 309     goto exitLblNotStarted;
 310     }
 311
 312 dataStore = storeLoader.GetStore();
 313 WriteServLog("Storage plugin: %s. Loading successfull.", dataStore->GetVersion().c_str());
 314
 315 tariffs = new TARIFFS_IMPL(dataStore);
 316 admins = new ADMINS_IMPL(dataStore);
 317 users = new USERS_IMPL(settings, dataStore, tariffs, admins->GetSysAdmin());
 318 traffCnt = new TRAFFCOUNTER_IMPL(users, settings->GetRulesFileName());
 319 services = new SERVICES_IMPL(dataStore);
 320 corps = new CORPORATIONS_IMPL(dataStore);
 321 traffCnt->SetMonitorDir(settings->GetMonitorDir());
 322
 323 modSettings = settings->GetModulesSettings();
 324
 325 for (size_t i = 0; i < modSettings.size(); i++)
 326     {
 327     string modulePath = settings->GetModulesPath();
 328     modulePath += "/mod_";
 329     modulePath += modSettings[i].moduleName;
 330     modulePath += ".so";
 331     printfd(__FILE__, "Module: %s\n", modulePath.c_str());
 332     modules.push_back(
 333         PLUGIN_RUNNER(modulePath,
 334                       modSettings[i],
 335                       admins,
 336                       tariffs,
 337                       users,
 338                       services,
 339                       corps,
 340                       traffCnt,
 341                       dataStore,
 342                       settings)
 343         );
 344     }
 345
 346 modIter = modules.begin();
 347
 348 while (modIter != modules.end())
 349     {
 350     if (modIter->Load())
 351         {
 352         WriteServLog("Error: %s",
 353                      modIter->GetStrError().c_str());
 354         goto exitLblNotStarted;
 355         }
 356     ++modIter;
 357     }
 358
 359 if (users->Start())
 360     {
 361     goto exitLblNotStarted;
 362     }
 363 WriteServLog("Users started successfully.");
 364
 365 if (traffCnt->Start())
 366     {
 367     goto exitLblNotStarted;
 368     }
 369 WriteServLog("Traffcounter started successfully.");
 370
 371 //Sort by start order
 372 modules.sort(StartModCmp);
 373 modIter = modules.begin();
 374
 375 while (modIter != modules.end())
 376     {
 377     if (modIter->Start())
 378         {
 379         WriteServLog("Error: %s",
 380                      modIter->GetStrError().c_str());
 381         goto exitLbl;
 382         }
 383     WriteServLog("Module: '%s'. Start successfull.", modIter->GetPlugin()->GetVersion().c_str());
 384     ++modIter;
 385     }
 386
 387 srandom(stgTime);
 388
 389 WriteServLog("Stg started successfully.");
 390 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
 391
 392 #ifndef NO_DAEMON
 393 creat(startFile.c_str(), S_IRUSR);
 394 #endif
 395
 396 sigset_t signalSet;
 397 sigfillset(&signalSet);
 398 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 399
 400 while (true)
 401     {
 402     sigfillset(&signalSet);
 403     int sig = 0;
 404     sigwait(&signalSet, &sig);
 405     bool stop = false;
 406     int status;
 407     pid_t childPid;
 408     set<pid_t>::iterator it;
 409     switch (sig)
 410         {
 411         case SIGHUP:
 412             traffCnt->Reload();
 413             modIter = modules.begin();
 414             for (; modIter != modules.end(); ++modIter)
 415                 {
 416                 if (modIter->Reload())
 417                     {
 418                     WriteServLog("Error reloading %s ('%s')", modIter->GetPlugin()->GetVersion().c_str(),
 419                                                               modIter->GetStrError().c_str());
 420                     printfd(__FILE__, "Error reloading %s ('%s')\n", modIter->GetPlugin()->GetVersion().c_str(),
 421                                                                      modIter->GetStrError().c_str());
 422                     }
 423                 }
 424             break;
 425         case SIGTERM:
 426             stop = true;
 427             break;
 428         case SIGINT:
 429             stop = true;
 430             break;
 431         case SIGPIPE:
 432             WriteServLog("Broken pipe!");
 433             break;
 434         case SIGCHLD:
 435             childPid = waitpid(-1, &status, WNOHANG);
 436
 437             it = executersPid.find(childPid);
 438             if (it != executersPid.end())
 439                 {
 440                 executersPid.erase(it);
 441                 if (executersPid.empty())
 442                     stop = true;
 443                 }
 444             break;
 445         default:
 446             WriteServLog("Ignore signel %d", sig);
 447             break;
 448         }
 449     if (stop)
 450         break;
 451     }
 452
 453 exitLbl:
 454
 455 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
 456
 457 //Sort by start order
 458 modules.sort(StopModCmp);
 459 modIter = modules.begin();
 460 while (modIter != modules.end())
 461     {
 462     std::string name = modIter->GetFileName();
 463     printfd(__FILE__, "Stopping module '%s'\n", name.c_str());
 464     if (modIter->Stop())
 465         {
 466         WriteServLog("Module \'%s\': Error: %s",
 467                      modIter->GetPlugin()->GetVersion().c_str(),
 468                      modIter->GetStrError().c_str());
 469         printfd(__FILE__, "Failed to stop module '%s'\n", name.c_str());
 470         }
 471     WriteServLog("Module: \'%s\'. Stop successfull.", modIter->GetPlugin()->GetVersion().c_str());
 472     ++modIter;
 473     }
 474
 475 if (loop.Stop())
 476     {
 477     WriteServLog("Event loop not stopped.");
 478     }
 479
 480 exitLblNotStarted:
 481
 482 modIter = modules.begin();
 483 while (modIter != modules.end())
 484     {
 485     std::string name = modIter->GetFileName();
 486     if (modIter->IsRunning())
 487         {
 488         printfd(__FILE__, "Passing module '%s' `cause it's still running\n", name.c_str());
 489         }
 490     else
 491         {
 492         printfd(__FILE__, "Unloading module '%s'\n", name.c_str());
 493         if (modIter->Unload())
 494             {
 495             WriteServLog("Module \'%s\': Error: %s",
 496                          name.c_str(),
 497                          modIter->GetStrError().c_str());
 498             printfd(__FILE__, "Failed to unload module '%s'\n", name.c_str());
 499             }
 500         }
 501     ++modIter;
 502     }
 503
 504 if (traffCnt)
 505     {
 506     traffCnt->Stop();
 507     WriteServLog("Traffcounter: Stop successfull.");
 508     }
 509
 510 if (users)
 511     {
 512     users->Stop();
 513     WriteServLog("Users: Stop successfull.");
 514     }
 515
 516 sleep(1);
 517 int res = msgctl(msgID, IPC_RMID, NULL);
 518 if (res)
 519     WriteServLog("Queue was not removed. id=%d", msgID);
 520 else
 521     WriteServLog("Queue removed successfully.");
 522
 523 KillExecuters();
 524
 525 StopStgTimer();
 526 WriteServLog("StgTimer: Stop successfull.");
 527
 528 delete corps;
 529 delete services;
 530 delete traffCnt;
 531 delete users;
 532 delete admins;
 533 delete tariffs;
 534 delete settings;
 535
 536 WriteServLog("Stg stopped successfully.");
 537 WriteServLog("---------------------------------------------");
 538
 539 return 0;
 540 }
 541 //-----------------------------------------------------------------------------