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