]> git.stg.codes - stg.git/blob - projects/stargazer/main.cpp
c7bfb4aaa1756ad4d1b3a2a0bc780e45a39b6e46
[stg.git] / 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/version.h"
50 #include "stg_timer.h"
51 #include "settings_impl.h"
52 #include "users_impl.h"
53 #include "admins_impl.h"
54 #include "tariffs_impl.h"
55 #include "services_impl.h"
56 #include "corps_impl.h"
57 #include "traffcounter_impl.h"
58 #include "plugin_runner.h"
59 #include "store_loader.h"
60 #include "pidfile.h"
61 #include "eventloop.h"
62
63 #ifdef DEBUG
64     #define MAIN_DEBUG (1)
65     #define NO_DAEMON  (1)
66 #endif
67
68 #define START_FILE "/._ST_ART_ED_"
69
70 namespace
71 {
72 std::set<pid_t> executersPid;
73
74 bool StartModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs);
75 bool StopModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs);
76 void StartTimer();
77 int StartScriptExecuter(char * procName, int msgKey, int * msgID, SETTINGS_IMPL * settings);
78 int ForkAndWait(const std::string & confDir);
79 void KillExecuters();
80
81 //-----------------------------------------------------------------------------
82 bool StartModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs)
83 {
84 return lhs.GetStartPosition() < rhs.GetStartPosition();
85 }
86 //-----------------------------------------------------------------------------
87 bool StopModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs)
88 {
89 return lhs.GetStopPosition() > rhs.GetStopPosition();
90 }
91 //-----------------------------------------------------------------------------
92 void StartTimer()
93 {
94 STG_LOGGER & WriteServLog = GetStgLogger();
95
96 if (RunStgTimer())
97     {
98     WriteServLog("Cannot start timer. Fatal.");
99     //printfd(__FILE__, "Cannot start timer. Fatal.\n");
100     exit(1);
101     }
102 else
103     {
104     WriteServLog("Timer thread started successfully.");
105     //printfd(__FILE__, "Timer thread started successfully.\n");
106     }
107 }
108 //-----------------------------------------------------------------------------
109 #ifdef LINUX
110 int StartScriptExecuter(char * procName, int msgKey, int * msgID, SETTINGS_IMPL * settings)
111 #else
112 int StartScriptExecuter(char *, int msgKey, int * msgID, SETTINGS_IMPL * settings)
113 #endif
114 {
115 STG_LOGGER & WriteServLog = GetStgLogger();
116
117 if (*msgID == -11)   // If msgID == -11 - first call. Create queue
118     {
119     for (int i = 0; i < 2; i++)
120         {
121         *msgID = msgget(msgKey, IPC_CREAT | IPC_EXCL | 0600);
122
123         if (*msgID == -1)
124             {
125             *msgID = msgget(msgKey, 0);
126             if (*msgID == -1)
127                 {
128                 WriteServLog("Message queue not created.");
129                 return -1;
130                 }
131             else
132                 {
133                 msgctl(*msgID, IPC_RMID, NULL);
134                 }
135             }
136         else
137             {
138             WriteServLog("Message queue created successfully. msgKey=%d msgID=%d", msgKey, *msgID);
139             break;
140             }
141         }
142     }
143
144 pid_t executerPid = fork();
145
146 switch (executerPid)
147     {
148     case -1:
149         WriteServLog("Fork error!");
150         return -1;
151
152     case 0:
153         delete settings;
154 #ifdef LINUX
155         Executer(*msgID, executerPid, procName);
156 #else
157         Executer(*msgID, executerPid);
158 #endif
159         return 1;
160
161     default:
162         if (executersPid.empty()) {
163 #ifdef LINUX
164             Executer(*msgID, executerPid, NULL);
165 #else
166             Executer(*msgID, executerPid);
167 #endif
168         }
169         executersPid.insert(executerPid);
170     }
171 return 0;
172 }
173 //-----------------------------------------------------------------------------
174 #ifndef NO_DAEMON
175 int ForkAndWait(const std::string & confDir)
176 #else
177 int ForkAndWait(const std::string &)
178 #endif
179 {
180 #ifndef NO_DAEMON
181 pid_t childPid = fork();
182 std::string startFile = confDir + START_FILE;
183 unlink(startFile.c_str());
184
185 switch (childPid)
186     {
187     case -1:
188         return -1;
189         break;
190
191     case 0:
192         close(1);
193         close(2);
194         setsid();
195         break;
196
197     default:
198         struct timespec ts = {0, 200000000};
199         for (int i = 0; i < 120 * 5; i++)
200             {
201             if (access(startFile.c_str(), F_OK) == 0)
202                 {
203                 unlink(startFile.c_str());
204                 exit(0);
205                 }
206
207             nanosleep(&ts, NULL);
208             }
209         unlink(startFile.c_str());
210         exit(1);
211         break;
212     }
213 #endif
214 return 0;
215 }
216 //-----------------------------------------------------------------------------
217 void KillExecuters()
218 {
219 std::set<pid_t>::iterator pid;
220 pid = executersPid.begin();
221 while (pid != executersPid.end())
222     {
223     printfd(__FILE__, "KillExecuters pid=%d\n", *pid);
224     kill(*pid, SIGUSR1);
225     ++pid;
226     }
227 }
228 //-----------------------------------------------------------------------------
229 } // namespace anonymous
230 //-----------------------------------------------------------------------------
231 int main(int argc, char * argv[])
232 {
233 SETTINGS_IMPL * settings = NULL;
234 STORE * dataStore = NULL;
235 TARIFFS_IMPL * tariffs = NULL;
236 ADMINS_IMPL * admins = NULL;
237 USERS_IMPL * users = NULL;
238 TRAFFCOUNTER_IMPL * traffCnt = NULL;
239 SERVICES_IMPL * services = NULL;
240 CORPORATIONS_IMPL * corps = NULL;
241 int msgID = -11;
242
243     {
244     STG_LOGGER & WriteServLog = GetStgLogger();
245     WriteServLog.SetLogFileName("/var/log/stargazer.log");
246     }
247
248 std::vector<MODULE_SETTINGS> modSettings;
249 std::list<PLUGIN_RUNNER> modules;
250
251 std::list<PLUGIN_RUNNER>::iterator modIter;
252
253 if (getuid())
254     {
255     printf("You must be root. Exit.\n");
256     exit(1);
257     }
258
259 if (argc == 2)
260     settings = new SETTINGS_IMPL(argv[1]);
261 else
262     settings = new SETTINGS_IMPL();
263
264 if (settings->ReadSettings())
265     {
266     STG_LOGGER & WriteServLog = GetStgLogger();
267     if (settings->GetLogFileName() != "")
268         WriteServLog.SetLogFileName(settings->GetLogFileName());
269
270     WriteServLog("ReadSettings error. %s", settings->GetStrError().c_str());
271     exit(1);
272     }
273 /*************************************************************************************************/
274 //вывод scriptParams
275     printfd(__FILE__, "--- Script params dump ---\n");
276     std::vector<std::string>::const_iterator it(settings->GetScriptParams().begin());
277     while (it != settings->GetScriptParams().end())
278     {
279         printfd(__FILE__, "%s\n", it->c_str());
280         it++;
281     }
282     printfd(__FILE__, "--- End dump ---\n"); 
283 /*************************************************************************************************/
284     
285 #ifndef NO_DAEMON
286 std::string startFile(settings->GetConfDir() + START_FILE);
287 #endif
288
289 if (ForkAndWait(settings->GetConfDir()) < 0)
290     {
291     STG_LOGGER & WriteServLog = GetStgLogger();
292     WriteServLog("Fork error!");
293     exit(1);
294     }
295
296 STG_LOGGER & WriteServLog = GetStgLogger();
297 WriteServLog.SetLogFileName(settings->GetLogFileName());
298 WriteServLog("Stg v. %s", SERVER_VERSION);
299
300 for (size_t i = 0; i < settings->GetExecutersNum(); i++)
301     {
302     int ret = StartScriptExecuter(argv[0], settings->GetExecMsgKey(), &msgID, settings);
303     if (ret < 0)
304         {
305         STG_LOGGER & WriteServLog = GetStgLogger();
306         WriteServLog("Start Script Executer error!");
307         return 1;
308         }
309     if (ret == 1)
310         {
311         // Stopping child
312         return 0;
313         }
314     }
315
316 PIDFile pidFile(settings->GetPIDFileName());
317
318 sigset_t signalSet;
319 sigfillset(&signalSet);
320 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
321
322 StartTimer();
323 WaitTimer();
324 if (!IsStgTimerRunning())
325     {
326     printfd(__FILE__, "Timer thread not started in 1 sec!\n");
327     WriteServLog("Timer thread not started in 1 sec!");
328     }
329
330 EVENT_LOOP & loop(EVENT_LOOP_SINGLETON::GetInstance());
331
332 STORE_LOADER storeLoader(*settings);
333 if (storeLoader.Load())
334     {
335     WriteServLog("Storage plugin: '%s'", storeLoader.GetStrError().c_str());
336     goto exitLblNotStarted;
337     }
338
339 if (loop.Start())
340     {
341     WriteServLog("Event loop not started.");
342     goto exitLblNotStarted;
343     }
344
345 dataStore = storeLoader.GetStore();
346 WriteServLog("Storage plugin: %s. Loading successfull.", dataStore->GetVersion().c_str());
347
348 tariffs = new TARIFFS_IMPL(dataStore);
349 admins = new ADMINS_IMPL(dataStore);
350 users = new USERS_IMPL(settings, dataStore, tariffs, admins->GetSysAdmin());
351 traffCnt = new TRAFFCOUNTER_IMPL(users, settings->GetRulesFileName());
352 services = new SERVICES_IMPL(dataStore);
353 corps = new CORPORATIONS_IMPL(dataStore);
354 traffCnt->SetMonitorDir(settings->GetMonitorDir());
355
356 modSettings = settings->GetModulesSettings();
357
358 for (size_t i = 0; i < modSettings.size(); i++)
359     {
360     std::string modulePath = settings->GetModulesPath();
361     modulePath += "/mod_";
362     modulePath += modSettings[i].moduleName;
363     modulePath += ".so";
364     printfd(__FILE__, "Module: %s\n", modulePath.c_str());
365     modules.push_back(
366         PLUGIN_RUNNER(modulePath,
367                       modSettings[i],
368                       admins,
369                       tariffs,
370                       users,
371                       services,
372                       corps,
373                       traffCnt,
374                       dataStore,
375                       settings)
376         );
377     }
378
379 modIter = modules.begin();
380
381 while (modIter != modules.end())
382     {
383     if (modIter->Load())
384         {
385         WriteServLog("Error loading module '%s': %s",
386                      modIter->GetPlugin()->GetVersion().c_str(),
387                      modIter->GetStrError().c_str());
388         goto exitLblNotStarted;
389         }
390     ++modIter;
391     }
392
393 if (users->Start())
394     {
395     goto exitLblNotStarted;
396     }
397 WriteServLog("Users started successfully.");
398
399 if (traffCnt->Start())
400     {
401     goto exitLblNotStarted;
402     }
403 WriteServLog("Traffcounter started successfully.");
404
405 //Sort by start order
406 modules.sort(StartModCmp);
407 modIter = modules.begin();
408
409 while (modIter != modules.end())
410     {
411     if (modIter->Start())
412         {
413         WriteServLog("Error starting module '%s': %s",
414                      modIter->GetPlugin()->GetVersion().c_str(),
415                      modIter->GetStrError().c_str());
416         goto exitLbl;
417         }
418     WriteServLog("Module: '%s'. Start successfull.", modIter->GetPlugin()->GetVersion().c_str());
419     ++modIter;
420     }
421
422 srandom(static_cast<unsigned int>(stgTime));
423
424 WriteServLog("Stg started successfully.");
425 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
426
427 #ifndef NO_DAEMON
428 creat(startFile.c_str(), S_IRUSR);
429 #endif
430
431 while (true)
432     {
433     sigfillset(&signalSet);
434     int sig = 0;
435     sigwait(&signalSet, &sig);
436     bool stop = false;
437     int status;
438     pid_t childPid;
439     std::set<pid_t>::iterator it;
440     switch (sig)
441         {
442         case SIGHUP:
443             traffCnt->Reload();
444             modIter = modules.begin();
445             for (; modIter != modules.end(); ++modIter)
446                 {
447                 if (modIter->Reload())
448                     {
449                     WriteServLog("Error reloading module '%s': '%s'", modIter->GetPlugin()->GetVersion().c_str(),
450                                                               modIter->GetStrError().c_str());
451                     printfd(__FILE__, "Error reloading module '%s': '%s'\n", modIter->GetPlugin()->GetVersion().c_str(),
452                                                                      modIter->GetStrError().c_str());
453                     }
454                 }
455             break;
456         case SIGTERM:
457             stop = true;
458             break;
459         case SIGINT:
460             stop = true;
461             break;
462         case SIGPIPE:
463             WriteServLog("Broken pipe!");
464             break;
465         case SIGCHLD:
466             childPid = waitpid(-1, &status, WNOHANG);
467
468             it = executersPid.find(childPid);
469             if (it != executersPid.end())
470                 {
471                 executersPid.erase(it);
472                 if (executersPid.empty())
473                     stop = true;
474                 }
475             break;
476         default:
477             WriteServLog("Ignore signel %d", sig);
478             break;
479         }
480     if (stop)
481         break;
482     }
483
484 exitLbl:
485
486 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
487
488 //Sort by start order
489 modules.sort(StopModCmp);
490 modIter = modules.begin();
491 while (modIter != modules.end())
492     {
493     std::string name = modIter->GetFileName();
494     printfd(__FILE__, "Stopping module '%s'\n", name.c_str());
495     if (modIter->Stop())
496         {
497         WriteServLog("Error stopping module '%s': %s",
498                      modIter->GetPlugin()->GetVersion().c_str(),
499                      modIter->GetStrError().c_str());
500         printfd(__FILE__, "Error stopping module '%s': '%s'\n", modIter->GetPlugin()->GetVersion().c_str(), modIter->GetStrError().c_str());
501         }
502     else
503         {
504         WriteServLog("Module: '%s'. Stop successfull.", modIter->GetPlugin()->GetVersion().c_str());
505         }
506     ++modIter;
507     }
508
509 if (loop.Stop())
510     {
511     WriteServLog("Event loop not stopped.");
512     }
513
514 exitLblNotStarted:
515
516 modIter = modules.begin();
517 while (modIter != modules.end())
518     {
519     std::string name = modIter->GetFileName();
520     if (modIter->IsRunning())
521         {
522         printfd(__FILE__, "Passing module '%s' `cause it's still running\n", name.c_str());
523         }
524     else
525         {
526         printfd(__FILE__, "Unloading module '%s'\n", name.c_str());
527         if (modIter->Unload())
528             {
529             WriteServLog("Error unloading module '%s': '%s'",
530                          modIter->GetPlugin()->GetVersion().c_str(),
531                          modIter->GetStrError().c_str());
532             printfd(__FILE__, "Error unloading module '%s': '%s'\n", modIter->GetPlugin()->GetVersion().c_str(), modIter->GetStrError().c_str());
533             }
534         }
535     ++modIter;
536     }
537
538 if (traffCnt)
539     {
540     traffCnt->Stop();
541     WriteServLog("Traffcounter: Stop successfull.");
542     }
543
544 if (users)
545     {
546     users->Stop();
547     WriteServLog("Users: Stop successfull.");
548     }
549
550 sleep(1);
551 int res = msgctl(msgID, IPC_RMID, NULL);
552 if (res)
553     WriteServLog("Queue was not removed. id=%d", msgID);
554 else
555     WriteServLog("Queue removed successfully.");
556
557 KillExecuters();
558
559 StopStgTimer();
560 WriteServLog("StgTimer: Stop successfull.");
561
562 delete corps;
563 delete services;
564 delete traffCnt;
565 delete users;
566 delete admins;
567 delete tariffs;
568 delete settings;
569
570 WriteServLog("Stg stopped successfully.");
571 WriteServLog("---------------------------------------------");
572
573 return 0;
574 }
575 //-----------------------------------------------------------------------------