WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom/src/main.cpp



#include "Socket/server.h"
#include "CanNet/cannetmanager.h"
#include "Socket/asyncsocket.h"
#include "VM/virtualmachine.h"
#include "CanNet/candebug.h"
 
#include "boost/thread.hpp"
 
bool cleanUpRunning = false;
int cleanUp();
void handler(int status);
 

            return cleanUp();
        }
    }
 
    string logfile = Settings::get("Logfile");
    if (logfile != "")
    {
        if (!log.open(logfile))
        {
            log.addToSyslog("Could not open logfile, " + logfile + "\n");
        }
        else
        {
            log.add("Logging to " + logfile + "\n");
        }
    }
    else
    {
        log.add("Logfile is not defined, logging will be done to syslog and console only\n");
    }
 
    VirtualMachine &vm = VirtualMachine::getInstance();
    vm.start();
 
    string canDebugPort = Settings::get("CanDebugPort");
    if (canDebugPort != "")
    {
        CanDebug &canDebug = CanDebug::getInstance();
        canDebug.setSettings(stoi(canDebugPort), "CanDebug");
        canDebug.start();
    }
    else
    {
        log.add("CanDebugPort is not defined, can not start CanDebug socket\n");
    }
 
    CanNetManager &canMan = CanNetManager::getInstance();
    canMan.start();
 
    if (Settings::get("DaemonMode") == "yes")
    {
        log.add("Entering daemon mode...\n");
        if (daemon(0, 0) == -1)
        {
            log.addToSyslog("Could not enter daemon mode. Exiting...\n");
            return cleanUp();

 
    vm.join();
 
    return cleanUp();
}
 
int cleanUp()
{
    Logger &log = Logger::getInstance();
 
    if (!cleanUpRunning)
    {
        cleanUpRunning = true;
 
        log.add("\n");
        log.addToSyslog("Thank you for using Atom. Goodbye!\n");
 
        CanDebug::deleteInstance();
        VirtualMachine::deleteInstance();

    }
    else
    {
        log.addToSyslog("Something has gone wrong clean up is already running!\n");
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}
 
void handler(int status)
{
    string signalName = "Unknown";
 
    switch (status)
    {
    case SIGTERM:
    signalName = "Terminate";
    break;
 
    case SIGINT:
    signalName = "Interupt";
    break;
 
    case SIGQUIT:
    signalName = "Quit";
    break;
 
    case SIGABRT:
    signalName = "Abort";
    break;
 
    case SIGIO:
    signalName = "I/O";
    break;
 
    case SIGPIPE:
    signalName = "Pipe";
    break;
    }
 
    Logger &log = Logger::getInstance();
    log.addToSyslog("Received signal " + signalName + "(" + itos(status) + ")\n");
 
    if (status == SIGPIPE)
    {
        return;
    }
 
    exit(cleanUp());
}

Rev 1124	Rev 1196
Line 32...	Line 32...
32	#include "Socket/server.h"	32	#include "Socket/server.h"
33	#include "CanNet/cannetmanager.h"	33	#include "CanNet/cannetmanager.h"
34	#include "Socket/asyncsocket.h"	34	#include "Socket/asyncsocket.h"
35	#include "VM/virtualmachine.h"	35	#include "VM/virtualmachine.h"
36	#include "CanNet/candebug.h"	36	#include "CanNet/candebug.h"
-		37
-		38	#include "boost/thread.hpp"
37		39
38	bool cleanUpRunning = false;	40	bool cleanUpRunning = false;
39	int cleanUp();	41	int cleanUp();
40	void handler(int status);	42	void handler(int status);
41		43
Line 66...	Line 68...
66	return cleanUp();	68	return cleanUp();
67	}	69	}
68	}	70	}
69		71
70	string logfile = Settings::get("Logfile");	72	string logfile = Settings::get("Logfile");
71	if (logfile != "")	73	if (logfile != "")
72	{	74	{
73	if (!log.open(logfile))	75	if (!log.open(logfile))
74	{	76	{
75	log.addToSyslog("Could not open logfile, " + logfile + "\n");	77	log.addToSyslog("Could not open logfile, " + logfile + "\n");
76	}	78	}
77	else	79	else
78	{	80	{
79	log.add("Logging to " + logfile + "\n");	81	log.add("Logging to " + logfile + "\n");
80	}	82	}
81	}	83	}
82	else	84	else
83	{	85	{
84	log.add("Logfile is not defined, logging will be done to syslog and console only\n");	86	log.add("Logfile is not defined, logging will be done to syslog and console only\n");
85	}	87	}
86		88
87	VirtualMachine &vm = VirtualMachine::getInstance();	89	VirtualMachine &vm = VirtualMachine::getInstance();
88	vm.start();	90	vm.start();
89		91
90	string canDebugPort = Settings::get("CanDebugPort");	92	string canDebugPort = Settings::get("CanDebugPort");
91	if (canDebugPort != "")	93	if (canDebugPort != "")
92	{	94	{
93	CanDebug &canDebug = CanDebug::getInstance();	95	CanDebug &canDebug = CanDebug::getInstance();
94	canDebug.setSettings(stoi(canDebugPort), "CanDebug");	96	canDebug.setSettings(stoi(canDebugPort), "CanDebug");
95	canDebug.start();	97	canDebug.start();
96	}	98	}
97	else	99	else
98	{	100	{
99	log.add("CanDebugPort is not defined, can not start CanDebug socket\n");	101	log.add("CanDebugPort is not defined, can not start CanDebug socket\n");
100	}	102	}
101		103
102	CanNetManager &canMan = CanNetManager::getInstance();	104	CanNetManager &canMan = CanNetManager::getInstance();
103	canMan.start();	105	canMan.start();
104		106
105	if (Settings::get("DaemonMode") == "yes")	107	if (Settings::get("DaemonMode") == "yes")
106	{	108	{
107	log.add("Entering daemon mode...\n");	109	log.add("Entering daemon mode...\n");
108	if (daemon(0, 0) == -1)	110	if (daemon(0, 0) == -1)
109	{	111	{
110	log.addToSyslog("Could not enter daemon mode. Exiting...\n");	112	log.addToSyslog("Could not enter daemon mode. Exiting...\n");
111	return cleanUp();	113	return cleanUp();
Line 114...	Line 116...
114		116
115	vm.join();	117	vm.join();
116		118
117	return cleanUp();	119	return cleanUp();
118	}	120	}
119		121
120	int cleanUp()	122	int cleanUp()
121	{	123	{
122	Logger &log = Logger::getInstance();	124	Logger &log = Logger::getInstance();
123		125
124	if (!cleanUpRunning)	126	if (!cleanUpRunning)
125	{	127	{
126	cleanUpRunning = true;	128	cleanUpRunning = true;
127		129
128	log.add("\n");	130	log.add("\n");
129	log.addToSyslog("Thank you for using Atom. Goodbye!\n");	131	log.addToSyslog("Thank you for using Atom. Goodbye!\n");
130		132
131	CanDebug::deleteInstance();	133	CanDebug::deleteInstance();
132	VirtualMachine::deleteInstance();	134	VirtualMachine::deleteInstance();
Line 135...	Line 137...
135	}	137	}
136	else	138	else
137	{	139	{
138	log.addToSyslog("Something has gone wrong clean up is already running!\n");	140	log.addToSyslog("Something has gone wrong clean up is already running!\n");
139	return EXIT_FAILURE;	141	return EXIT_FAILURE;
140	}	142	}
141		143
142	return EXIT_SUCCESS;	144	return EXIT_SUCCESS;
143	}	145	}
144		146
145	void handler(int status)	147	void handler(int status)
146	{	148	{
147	string signalName = "Unknown";	149	string signalName = "Unknown";
148		150
149	switch (status)	151	switch (status)
150	{	152	{
151	case SIGTERM:	153	case SIGTERM:
152	signalName = "Terminate";	154	signalName = "Terminate";
153	break;	155	break;
154		156
155	case SIGINT:	157	case SIGINT:
156	signalName = "Interupt";	158	signalName = "Interupt";
157	break;	159	break;
158		160
159	case SIGQUIT:	161	case SIGQUIT:
160	signalName = "Quit";	162	signalName = "Quit";
161	break;	163	break;
162		164
163	case SIGABRT:	165	case SIGABRT:
164	signalName = "Abort";	166	signalName = "Abort";
165	break;	167	break;
166		168
167	case SIGIO:	169	case SIGIO:
168	signalName = "I/O";	170	signalName = "I/O";
169	break;	171	break;
170		172
171	case SIGPIPE:	173	case SIGPIPE:
172	signalName = "Pipe";	174	signalName = "Pipe";
173	break;	175	break;
174	}	176	}
175		177
176	Logger &log = Logger::getInstance();	178	Logger &log = Logger::getInstance();
177	log.addToSyslog("Received signal " + signalName + "(" + itos(status) + ")\n");	179	log.addToSyslog("Received signal " + signalName + "(" + itos(status) + ")\n");
178		180
179	if (status == SIGPIPE)	181	if (status == SIGPIPE)
180	{	182	{
181	return;	183	return;
182	}	184	}
183		185
184	exit(cleanUp());	186	exit(cleanUp());
185	}	187	}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/src/main.cpp – Rev 1124 → 1196