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


/***************************************************************************
 *   Copyright (C) November 26, 2008, 3:00 PM by Mattias Runge             *
 *   mattias@runge.se                                                      *
 *   main.cpp                                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
using namespace std;
 
 
#include <stdlib.h>
#include <iostream>
#include <signal.h>
 
#include "version.h"
#include "Tools/tools.h"
#include "SyslogStream/syslogstream.h"
#include "Settings/settings.h"
#include "CanNet/cannetmanager.h"
#include "Socket/asyncsocket.h"
#include "VM/virtualmachine.h"
 
int cleanUp();
void handler(int status);
 
int main(int argc, char** argv)
{
    signal(SIGTERM, handler);
    signal(SIGINT, handler);
    signal(SIGQUIT, handler);
    signal(SIGABRT, handler);
    signal(SIGPIPE, handler);
 
    SyslogStream &slog = SyslogStream::getInstance();
 
    slog << "Atom " + ftos(VERSION) + " starting...\n";
    slog << "Written by Mattias Runge 2008\n\n";
 
    if (file_exists("/etc/atom.conf"))
    {
        if (!Settings::read("/etc/atom.conf"))
        {
            return cleanUp();
        }
    }
    else
    {
        if (!Settings::read("atom.conf"))
        {
            return cleanUp();
        }
    }
 
 
    VirtualMachine &vm = VirtualMachine::getInstance();
 
    vm.start();
 
    if (Settings::get("DaemonMode") == "yes")
    {
        slog << "Entering daemon mode...\n";
        if (daemon(0, 0) == -1)
        {
            slog << "Could not enter daemon mode. Exiting...\n";
            return cleanUp();
        }
    }
 
    CanNetManager &canMan = CanNetManager::getInstance();
 
    canMan.openChannel();
 
    return cleanUp();
}
 
int cleanUp()
{
    SyslogStream &slog = SyslogStream::getInstance();
 
    slog << "\n";
    slog << "Goodbye!\n";
   
    CanNetManager::deleteInstance();
    VirtualMachine::deleteInstance();
    SyslogStream::deleteInstance();
 
    return EXIT_SUCCESS;
}
 
void handler(int status)
{
    //cout << "In the handler function. Status: " << status << endl;
 
/*
    cout << "SIGTERM: " << SIGTERM << endl;
    cout << "SIGINT: " << SIGINT << endl;
    cout << "SIGQUIT: " << SIGQUIT << endl;
    cout << "SIGABRT: " << SIGABRT << endl;
    cout << "SIGIO: " << SIGIO << endl;
    cout << "SIGPIPE: " << SIGPIPE << endl;
 
*/
    cleanUp();
 
    /*The SIGTERM signal tells a process to exit, so we exit. You can't make a
    process invincible by ignoreing SIGTERM as there are still the
    SIGKILL and SIGSTOP signals which you can't set a handler for (catch) or
    ignore*/
    exit(EXIT_SUCCESS);
}
 

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/main.cpp @ 978 – Rev 976 → 978

Rev 976		Rev 978
1	/***************************************************************************	1	/***************************************************************************
2	* Copyright (C) November 26, 2008, 3:00 PM by Mattias Runge *	2	* Copyright (C) November 26, 2008, 3:00 PM by Mattias Runge *
3	* mattias@runge.se *	3	* mattias@runge.se *
4	* main.cpp *	4	* main.cpp *
5	* *	5	* *
6	* This program is free software; you can redistribute it and/or modify *	6	* This program is free software; you can redistribute it and/or modify *
7	* it under the terms of the GNU General Public License as published by *	7	* it under the terms of the GNU General Public License as published by *
8	* the Free Software Foundation; either version 2 of the License, or *	8	* the Free Software Foundation; either version 2 of the License, or *
9	* (at your option) any later version. *	9	* (at your option) any later version. *
10	* *	10	* *
11	* This program is distributed in the hope that it will be useful, *	11	* This program is distributed in the hope that it will be useful, *
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14	* GNU General Public License for more details. *	14	* GNU General Public License for more details. *
15	* *	15	* *
16	* You should have received a copy of the GNU General Public License *	16	* You should have received a copy of the GNU General Public License *
17	* along with this program; if not, write to the *	17	* along with this program; if not, write to the *
18	* Free Software Foundation, Inc., *	18	* Free Software Foundation, Inc., *
19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
20	***************************************************************************/	20	***************************************************************************/
21		21
22	using namespace std;	22	using namespace std;
23		23
24		24
25	#include <stdlib.h>	25	#include <stdlib.h>
26	#include <iostream>	26	#include <iostream>
27	#include <signal.h>	27	#include <signal.h>
28		28
29	#include "version.h"	29	#include "version.h"
30	#include "Tools/tools.h"	30	#include "Tools/tools.h"
31	#include "SyslogStream/syslogstream.h"	31	#include "SyslogStream/syslogstream.h"
32	#include "Settings/settings.h"	32	#include "Settings/settings.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		36
37	int cleanUp();	37	int cleanUp();
38	void handler(int status);	38	void handler(int status);
39		39
40	int main(int argc, char** argv)	40	int main(int argc, char** argv)
41	{	41	{
42	signal(SIGTERM, handler);	42	signal(SIGTERM, handler);
43	signal(SIGINT, handler);	43	signal(SIGINT, handler);
44	signal(SIGQUIT, handler);	44	signal(SIGQUIT, handler);
45	signal(SIGABRT, handler);	45	signal(SIGABRT, handler);
46	signal(SIGPIPE, handler);	46	signal(SIGPIPE, handler);
47		47
48	SyslogStream &slog = SyslogStream::getInstance();	48	SyslogStream &slog = SyslogStream::getInstance();
49		49
50	slog << "Atom " + ftos(VERSION) + " starting...\n";	50	slog << "Atom " + ftos(VERSION) + " starting...\n";
51	slog << "Written by Mattias Runge 2008\n\n";	51	slog << "Written by Mattias Runge 2008\n\n";
52		52
53	if (file_exists("/etc/atom.conf"))	53	if (file_exists("/etc/atom.conf"))
54	{	54	{
55	if (!Settings::read("/etc/atom.conf"))	55	if (!Settings::read("/etc/atom.conf"))
56	{	56	{
57	return cleanUp();	57	return cleanUp();
58	}	58	}
59	}	59	}
60	else	60	else
61	{	61	{
62	if (!Settings::read("atom.conf"))	62	if (!Settings::read("atom.conf"))
63	{	63	{
64	return cleanUp();	64	return cleanUp();
65	}	65	}
66	}	66	}
67		67
68		68
69	VirtualMachine &vm = VirtualMachine::getInstance();	69	VirtualMachine &vm = VirtualMachine::getInstance();
70		70
71	vm.start();	71	vm.start();
72		72
73	if (Settings::get("DaemonMode") == "yes")	73	if (Settings::get("DaemonMode") == "yes")
74	{	74	{
75	slog << "Entering daemon mode...\n";	75	slog << "Entering daemon mode...\n";
76	if (daemon(0, 0) == -1)	76	if (daemon(0, 0) == -1)
77	{	77	{
78	slog << "Could not enter daemon mode. Exiting...\n";	78	slog << "Could not enter daemon mode. Exiting...\n";
79	return cleanUp();	79	return cleanUp();
80	}	80	}
81	}	81	}
82		82
83	CanNetManager &canMan = CanNetManager::getInstance();	83	CanNetManager &canMan = CanNetManager::getInstance();
84		84
85	canMan.openChannel();	85	canMan.openChannel();
86		86
87	return cleanUp();	87	return cleanUp();
88	}	88	}
89		89
90	int cleanUp()	90	int cleanUp()
91	{	91	{
92	SyslogStream &slog = SyslogStream::getInstance();	92	SyslogStream &slog = SyslogStream::getInstance();
93		93
-		94	slog << "\n";
94	slog << "\nGoodbye!\n";	95	slog << "Goodbye!\n";
95		96
96	CanNetManager::deleteInstance();	97	CanNetManager::deleteInstance();
97	VirtualMachine::deleteInstance();	98	VirtualMachine::deleteInstance();
98	SyslogStream::deleteInstance();	99	SyslogStream::deleteInstance();
99		100
100	return EXIT_SUCCESS;	101	return EXIT_SUCCESS;
101	}	102	}
102		103
103	void handler(int status)	104	void handler(int status)
104	{	105	{
105	//cout << "In the handler function. Status: " << status << endl;	106	//cout << "In the handler function. Status: " << status << endl;
106		107
107	/*	108	/*
108	cout << "SIGTERM: " << SIGTERM << endl;	109	cout << "SIGTERM: " << SIGTERM << endl;
109	cout << "SIGINT: " << SIGINT << endl;	110	cout << "SIGINT: " << SIGINT << endl;
110	cout << "SIGQUIT: " << SIGQUIT << endl;	111	cout << "SIGQUIT: " << SIGQUIT << endl;
111	cout << "SIGABRT: " << SIGABRT << endl;	112	cout << "SIGABRT: " << SIGABRT << endl;
112	cout << "SIGIO: " << SIGIO << endl;	113	cout << "SIGIO: " << SIGIO << endl;
113	cout << "SIGPIPE: " << SIGPIPE << endl;	114	cout << "SIGPIPE: " << SIGPIPE << endl;
114		115
115	*/	116	*/
116	cleanUp();	117	cleanUp();
117		118
118	/*The SIGTERM signal tells a process to exit, so we exit. You can't make a	119	/*The SIGTERM signal tells a process to exit, so we exit. You can't make a
119	process invincible by ignoreing SIGTERM as there are still the	120	process invincible by ignoreing SIGTERM as there are still the
120	SIGKILL and SIGSTOP signals which you can't set a handler for (catch) or	121	SIGKILL and SIGSTOP signals which you can't set a handler for (catch) or
121	ignore*/	122	ignore*/
122	exit(EXIT_SUCCESS);	123	exit(EXIT_SUCCESS);
123	}	124	}
124		125