]> git.stg.codes - stg.git/blob - projects/stargazer/main.cpp
Ticket 37. WriteTime() changed to WriteString() and formatTime() added
[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 #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 //-----------------------------------------------------------------------------