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 #include "store_loader.h"
  22 #include "plugin_mgr.h"
  23 #include "plugin_runner.h"
  24 #include "users_impl.h"
  25 #include "admins_impl.h"
  26 #include "tariffs_impl.h"
  27 #include "services_impl.h"
  28 #include "corps_impl.h"
  29 #include "traffcounter_impl.h"
  30 #include "settings_impl.h"
  31 #include "pidfile.h"
  32 #include "eventloop.h"
  33 #include "stg_timer.h"
  34
  35 #include "stg/user.h"
  36 #include "stg/common.h"
  37 #include "stg/plugin.h"
  38 #include "stg/logger.h"
  39 #include "stg/scriptexecuter.h"
  40 #include "stg/version.h"
  41
  42 #include <fstream>
  43 #include <vector>
  44 #include <set>
  45 #include <csignal>
  46 #include <cerrno>
  47 #include <cstdio>
  48 #include <cstdlib> // srandom, exit
  49
  50 #include <unistd.h>
  51 #include <sys/ipc.h>
  52 #include <sys/msg.h>
  53 #include <sys/types.h>
  54 #include <sys/wait.h>
  55 #include <sys/stat.h> // S_IRUSR
  56 #include <fcntl.h> // create
  57
  58 #ifdef DEBUG
  59     #define NO_DAEMON  (1)
  60 #endif
  61
  62 #define START_FILE "/._ST_ART_ED_"
  63
  64 namespace
  65 {
  66 std::set<pid_t> executers;
  67
  68 void StartTimer();
  69 int StartScriptExecuter(char * procName, int msgKey, int * msgID);
  70 int ForkAndWait(const std::string & confDir);
  71 void KillExecuters();
  72
  73 //-----------------------------------------------------------------------------
  74 void StartTimer()
  75 {
  76 STG_LOGGER & WriteServLog = GetStgLogger();
  77
  78 if (RunStgTimer())
  79     {
  80     WriteServLog("Cannot start timer. Fatal.");
  81     //printfd(__FILE__, "Cannot start timer. Fatal.\n");
  82     exit(1);
  83     }
  84 else
  85     {
  86     WriteServLog("Timer thread started successfully.");
  87     //printfd(__FILE__, "Timer thread started successfully.\n");
  88     }
  89 }
  90 //-----------------------------------------------------------------------------
  91 #if defined(LINUX) || defined(DARWIN)
  92 int StartScriptExecuter(char * procName, int msgKey, int * msgID)
  93 #else
  94 int StartScriptExecuter(char *, int msgKey, int * msgID)
  95 #endif
  96 {
  97 STG_LOGGER & WriteServLog = GetStgLogger();
  98
  99 if (*msgID == -11)   // If msgID == -11 - first call. Create queue
 100     {
 101     for (int i = 0; i < 2; i++)
 102         {
 103         *msgID = msgget(msgKey, IPC_CREAT | IPC_EXCL | 0600);
 104
 105         if (*msgID == -1)
 106             {
 107             *msgID = msgget(msgKey, 0);
 108             if (*msgID == -1)
 109                 {
 110                 WriteServLog("Message queue not created.");
 111                 return -1;
 112                 }
 113             else
 114                 {
 115                 msgctl(*msgID, IPC_RMID, NULL);
 116                 }
 117             }
 118         else
 119             {
 120             WriteServLog("Message queue created successfully. msgKey=%d msgID=%d", msgKey, *msgID);
 121             break;
 122             }
 123         }
 124     }
 125
 126 pid_t pid = fork();
 127
 128 switch (pid)
 129     {
 130     case -1:
 131         WriteServLog("Fork error!");
 132         return -1;
 133
 134     case 0:
 135 #if defined(LINUX) || defined(DARWIN)
 136         Executer(*msgID, pid, procName);
 137 #else
 138         Executer(*msgID, pid);
 139 #endif
 140         return 1;
 141
 142     default:
 143         if (executers.empty()) {
 144 #if defined(LINUX) || defined(DARWIN)
 145             Executer(*msgID, pid, NULL);
 146 #else
 147             Executer(*msgID, pid);
 148 #endif
 149         }
 150         executers.insert(pid);
 151     }
 152 return 0;
 153 }
 154 //-----------------------------------------------------------------------------
 155 #ifndef NO_DAEMON
 156 int ForkAndWait(const std::string & confDir)
 157 #else
 158 int ForkAndWait(const std::string &)
 159 #endif
 160 {
 161 #ifndef NO_DAEMON
 162 pid_t pid = fork();
 163 std::string startFile = confDir + START_FILE;
 164 unlink(startFile.c_str());
 165
 166 switch (pid)
 167     {
 168     case -1:
 169         return -1;
 170         break;
 171
 172     case 0:
 173         close(1);
 174         close(2);
 175         setsid();
 176         break;
 177
 178     default:
 179         struct timespec ts = {0, 200000000};
 180         for (int i = 0; i < 120 * 5; i++)
 181             {
 182             if (access(startFile.c_str(), F_OK) == 0)
 183                 {
 184                 unlink(startFile.c_str());
 185                 exit(0);
 186                 }
 187
 188             nanosleep(&ts, NULL);
 189             }
 190         unlink(startFile.c_str());
 191         exit(1);
 192         break;
 193     }
 194 #endif
 195 return 0;
 196 }
 197 //-----------------------------------------------------------------------------
 198 void KillExecuters()
 199 {
 200 std::set<pid_t>::iterator pid(executers.begin());
 201 while (pid != executers.end())
 202     {
 203     printfd(__FILE__, "KillExecuters pid=%d\n", *pid);
 204     kill(*pid, SIGUSR1);
 205     ++pid;
 206     }
 207 }
 208 //-----------------------------------------------------------------------------
 209 } // namespace anonymous
 210 //-----------------------------------------------------------------------------
 211 int main(int argc, char * argv[])
 212 {
 213 int msgID = -11;
 214
 215 GetStgLogger().SetLogFileName("/var/log/stargazer.log");
 216
 217 if (getuid())
 218     {
 219     printf("You must be root. Exit.\n");
 220     return 1;
 221     }
 222
 223 SETTINGS_IMPL settings(argc == 2 ? argv[1] : "");
 224
 225 if (settings.ReadSettings())
 226     {
 227     STG_LOGGER & WriteServLog = GetStgLogger();
 228
 229     if (settings.GetLogFileName() != "")
 230         WriteServLog.SetLogFileName(settings.GetLogFileName());
 231
 232     WriteServLog("ReadSettings error. %s", settings.GetStrError().c_str());
 233     return -1;
 234     }
 235
 236 #ifndef NO_DAEMON
 237 std::string startFile(settings.GetConfDir() + START_FILE);
 238 #endif
 239
 240 if (ForkAndWait(settings.GetConfDir()) < 0)
 241     {
 242     STG_LOGGER & WriteServLog = GetStgLogger();
 243     WriteServLog("Fork error!");
 244     return -1;
 245     }
 246
 247 STG_LOGGER & WriteServLog = GetStgLogger();
 248 WriteServLog.SetLogFileName(settings.GetLogFileName());
 249 WriteServLog("Stg v. %s", SERVER_VERSION);
 250
 251 for (size_t i = 0; i < settings.GetExecutersNum(); i++)
 252     {
 253     int ret = StartScriptExecuter(argv[0], settings.GetExecMsgKey(), &msgID);
 254     if (ret < 0)
 255         {
 256         STG_LOGGER & WriteServLog = GetStgLogger();
 257         WriteServLog("Start Script Executer error!");
 258         return -1;
 259         }
 260     if (ret == 1)
 261         {
 262         // Stopping child
 263         return 0;
 264         }
 265     }
 266
 267 PIDFile pidFile(settings.GetPIDFileName());
 268
 269 struct sigaction sa;
 270 memset(&sa, 0, sizeof(sa));
 271 sa.sa_handler = SIG_DFL;
 272 sigaction(SIGHUP, &sa, NULL); // Apparently FreeBSD ignores SIGHUP by default when launched from rc.d at bot time.
 273
 274 sigset_t signalSet;
 275 sigfillset(&signalSet);
 276 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 277
 278 StartTimer();
 279 WaitTimer();
 280 if (!IsStgTimerRunning())
 281     {
 282     printfd(__FILE__, "Timer thread not started in 1 sec!\n");
 283     WriteServLog("Timer thread not started in 1 sec!");
 284     return -1;
 285     }
 286
 287 EVENT_LOOP & loop(EVENT_LOOP_SINGLETON::GetInstance());
 288
 289 STORE_LOADER storeLoader(settings);
 290 if (storeLoader.Load())
 291     {
 292     printfd(__FILE__, "Storage plugin: '%s'\n", storeLoader.GetStrError().c_str());
 293     WriteServLog("Storage plugin: '%s'", storeLoader.GetStrError().c_str());
 294     return -1;
 295     }
 296
 297 if (loop.Start())
 298     {
 299     printfd(__FILE__, "Event loop not started.\n");
 300     WriteServLog("Event loop not started.");
 301     return -1;
 302     }
 303
 304 STORE & store(storeLoader.GetStore());
 305 WriteServLog("Storage plugin: %s. Loading successfull.", store.GetVersion().c_str());
 306
 307 ADMINS_IMPL admins(&store);
 308 TARIFFS_IMPL tariffs(&store);
 309 SERVICES_IMPL services(&store);
 310 CORPORATIONS_IMPL corps(&store);
 311 USERS_IMPL users(&settings, &store, &tariffs, services, admins.GetSysAdmin());
 312 TRAFFCOUNTER_IMPL traffCnt(&users, settings.GetRulesFileName());
 313 traffCnt.SetMonitorDir(settings.GetMonitorDir());
 314
 315 if (users.Start())
 316     return -1;
 317
 318 WriteServLog("Users started successfully.");
 319
 320 if (traffCnt.Start())
 321     return -1;
 322
 323 WriteServLog("Traffcounter started successfully.");
 324
 325 STG::PluginManager manager(settings, store, admins, tariffs, services, corps, users, traffCnt);
 326
 327 srandom(static_cast<unsigned int>(stgTime));
 328
 329 WriteServLog("Stg started successfully.");
 330 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
 331
 332 #ifndef NO_DAEMON
 333 creat(startFile.c_str(), S_IRUSR);
 334 #endif
 335
 336 bool running = true;
 337 while (running)
 338     {
 339     sigfillset(&signalSet);
 340     int sig = 0;
 341     sigwait(&signalSet, &sig);
 342     int status;
 343     switch (sig)
 344         {
 345         case SIGHUP:
 346             {
 347             SETTINGS_IMPL newSettings(settings);
 348             if (newSettings.ReadSettings())
 349                 WriteServLog("ReadSettings error. %s", newSettings.GetStrError().c_str());
 350             else
 351                 settings = newSettings;
 352             WriteServLog.SetLogFileName(settings.GetLogFileName());
 353             traffCnt.Reload();
 354             manager.reload(settings);
 355             }
 356             break;
 357         case SIGTERM:
 358             running = false;
 359             break;
 360         case SIGINT:
 361             running = false;
 362             break;
 363         case SIGPIPE:
 364             WriteServLog("Broken pipe!");
 365             break;
 366         case SIGCHLD:
 367             executers.erase(waitpid(-1, &status, WNOHANG));
 368             if (executers.empty())
 369                 running = false;
 370             break;
 371         default:
 372             WriteServLog("Ignore signal %d", sig);
 373             break;
 374         }
 375     }
 376
 377 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
 378
 379 manager.stop();
 380
 381 if (loop.Stop())
 382     WriteServLog("Event loop not stopped.");
 383
 384 if (!traffCnt.Stop())
 385     WriteServLog("Traffcounter: Stop successfull.");
 386
 387 if (!users.Stop())
 388     WriteServLog("Users: Stop successfull.");
 389
 390 sleep(1);
 391 int res = msgctl(msgID, IPC_RMID, NULL);
 392 if (res)
 393     WriteServLog("Queue was not removed. id=%d", msgID);
 394 else
 395     WriteServLog("Queue removed successfully.");
 396
 397 KillExecuters();
 398
 399 StopStgTimer();
 400 WriteServLog("StgTimer: Stop successfull.");
 401
 402 WriteServLog("Stg stopped successfully.");
 403 WriteServLog("---------------------------------------------");
 404
 405 return 0;
 406 }
 407 //-----------------------------------------------------------------------------