WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/main.cpp


/*
 *
 *  Copyright (C) 2010  Mattias Runge
 *
 *  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.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
 
#include <signal.h>
 
#include <boost/program_options.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/locks.hpp>
 
#include "logging/Logger.h"
#include "net/Manager.h"
#include "timer/Manager.h"
#include "config/Manager.h"
#include "can/Protocol.h"
#include "broker/Manager.h"
#include "can/Manager.h"
#include "can/Network.h"
#include "can/Monitor.h"
#include "vm/Manager.h"
 
#include "vm/plugin/System.h"
#include "vm/plugin/Timer.h"
#include "vm/plugin/Module.h"
 
using namespace atom;
 
logging::Logger LOG("Main");
std::vector<broker::Subscriber::Pointer> subscribers;
boost::condition on_message_condition;
boost::mutex guard_mutex;
 
void Handler(int status);
void CleanUp();
 
int main(int argc, char **argv)
{
    LOG.Info("Atom version 1.5.0 starting...");
    LOG.Info("Written by Mattias Runge 2010.");
    LOG.Info("Released under GPL version 2.");
   
    signal(SIGTERM, Handler);
    signal(SIGINT, Handler);
    signal(SIGQUIT, Handler);
    signal(SIGABRT, Handler);
    signal(SIGPIPE, Handler);
   
    config::Manager::Create();
   
    if (!config::Manager::Instance()->Set(argc, argv))
    {
        CleanUp();
        return EXIT_SUCCESS;
    }
   
    if (config::Manager::Instance()->Exist("LogFile"))
    {
        logging::Logger::OpenFile(config::Manager::Instance()->GetAsString("LogFile"));
    }
   
    if (config::Manager::Instance()->Exist("LogLevel"))
    {
        logging::Logger::SetLevel((logging::Logger::Level)config::Manager::Instance()->GetAsInt("LogLevel"));
    }
   
    if (config::Manager::Instance()->Exist("daemon"))
    {
        LOG.Info("Entering daemon mode...");
       
        if (daemon(0, 0) == -1)
        {
            LOG.Error("Could not enter daemon mode. Exiting...");
            CleanUp();
            return EXIT_FAILURE;
        }
       
        LOG.Info("Deamon mode entered successfully!");
    }
 
    timer::Manager::Create();
    broker::Manager::Create();
    net::Manager::Create();
    can::Protocol::Create();
    can::Manager::Create();
    vm::Manager::Create();
   
    if (config::Manager::Instance()->Exist("ProtocolFile"))
    {
        can::Protocol::Instance()->Load(config::Manager::Instance()->GetAsString("ProtocolFile"));
    }
   
    if (config::Manager::Instance()->Exist("MonitorPort"))
    {
        subscribers.push_back(can::Monitor::Pointer(new can::Monitor(config::Manager::Instance()->GetAsInt("MonitorPort"))));  
    }
   
    subscribers.push_back(can::Manager::Instance());  
   
    if (config::Manager::Instance()->Exist("CanNet"))
    {
        type::StringList cannetworks = config::Manager::Instance()->GetAsStringVector("CanNet");
       
        for (int n = 0; n < cannetworks.size(); n++)
        {
            subscribers.push_back(can::Network::Pointer(new can::Network(cannetworks[n])));            
        }
    }
 
    vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::System()));
    vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::Timer()));
    vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::Module()));
 
    if (config::Manager::Instance()->Exist("ScriptPath"))
    {
        vm::Manager::Instance()->Start(config::Manager::Instance()->GetAsString("ScriptPath"));
    }
   
    LOG.Info("Initialization complete.");
   
    boost::mutex::scoped_lock guard(guard_mutex);
    on_message_condition.wait(guard);
   
    LOG.Info("Cleaning up...");
   
    CleanUp();
   
    LOG.Info("Thank you for using Atom. Goodbye!");
   
    return EXIT_SUCCESS;
}
 
void CleanUp()
{
    subscribers.clear();
 
    config::Manager::Delete();
    timer::Manager::Delete();
    can::Manager::Delete();
    vm::Manager::Delete();
    can::Protocol::Delete();
    broker::Manager::Delete();
    net::Manager::Delete();
}
 
void Handler(int status)
{
    std::string signal_name = "Unknown";
   
    switch (status)
    {
        case SIGTERM:
        {
            signal_name = "Terminate";
            break;
        }  
        case SIGINT:
        {
            signal_name = "Interupt";
            break;
        }  
        case SIGQUIT:
        {
            signal_name = "Quit";
            break;
        }  
        case SIGABRT:
        {
            signal_name = "Abort";
            break;
        }  
        case SIGIO:
        {
            signal_name = "I/O";
            break;
        }  
        case SIGPIPE:
        {
            signal_name = "Pipe";
            break;
        }
    }
   
    LOG.Debug("Received signal " + signal_name + "(" + boost::lexical_cast<std::string>(status) + ").");
   
    if (status != SIGPIPE)
    {
        on_message_condition.notify_all();
    }
}

Rev 1601	Rev 1602
1	/*	1	/*
2	*	2	*
3	* Copyright (C) 2010 Mattias Runge	3	* Copyright (C) 2010 Mattias Runge
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or	7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License along	15	* You should have received a copy of the GNU General Public License along
16	* with this program; if not, write to the Free Software Foundation, Inc.,	16	* with this program; if not, write to the Free Software Foundation, Inc.,
17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	*	18	*
19	*/	19	*/
20		20
21	#include <signal.h>	21	#include <signal.h>
22		22
23	#include <boost/program_options.hpp>	23	#include <boost/program_options.hpp>
24	#include <boost/thread/mutex.hpp>	24	#include <boost/thread/mutex.hpp>
25	#include <boost/thread/condition.hpp>	25	#include <boost/thread/condition.hpp>
26	#include <boost/thread/locks.hpp>	26	#include <boost/thread/locks.hpp>
27		27
28	#include "logging/Logger.h"	28	#include "logging/Logger.h"
29	#include "net/Manager.h"	29	#include "net/Manager.h"
30	#include "timer/Manager.h"	30	#include "timer/Manager.h"
31	#include "config/Manager.h"	31	#include "config/Manager.h"
32	#include "can/Protocol.h"	32	#include "can/Protocol.h"
33	#include "broker/Manager.h"	33	#include "broker/Manager.h"
34	#include "can/Manager.h"	34	#include "can/Manager.h"
35	#include "can/Network.h"	35	#include "can/Network.h"
36	#include "can/Monitor.h"	36	#include "can/Monitor.h"
37	#include "vm/Manager.h"	37	#include "vm/Manager.h"
38		38
39	#include "vm/plugin/System.h"	39	#include "vm/plugin/System.h"
40	#include "vm/plugin/Timer.h"	40	#include "vm/plugin/Timer.h"
-		41	#include "vm/plugin/Module.h"
41		42
42	using namespace atom;	43	using namespace atom;
43		44
44	logging::Logger LOG("Main");	45	logging::Logger LOG("Main");
45	std::vector<broker::Subscriber::Pointer> subscribers;	46	std::vector<broker::Subscriber::Pointer> subscribers;
46	boost::condition on_message_condition;	47	boost::condition on_message_condition;
47	boost::mutex guard_mutex;	48	boost::mutex guard_mutex;
48		49
49	void Handler(int status);	50	void Handler(int status);
50	void CleanUp();	51	void CleanUp();
51		52
52	int main(int argc, char **argv)	53	int main(int argc, char **argv)
53	{	54	{
54	LOG.Info("Atom version 1.5.0 starting...");	55	LOG.Info("Atom version 1.5.0 starting...");
55	LOG.Info("Written by Mattias Runge 2010.");	56	LOG.Info("Written by Mattias Runge 2010.");
56	LOG.Info("Released under GPL version 2.");	57	LOG.Info("Released under GPL version 2.");
57		58
58	signal(SIGTERM, Handler);	59	signal(SIGTERM, Handler);
59	signal(SIGINT, Handler);	60	signal(SIGINT, Handler);
60	signal(SIGQUIT, Handler);	61	signal(SIGQUIT, Handler);
61	signal(SIGABRT, Handler);	62	signal(SIGABRT, Handler);
62	signal(SIGPIPE, Handler);	63	signal(SIGPIPE, Handler);
63		64
64	config::Manager::Create();	65	config::Manager::Create();
65		66
66	if (!config::Manager::Instance()->Set(argc, argv))	67	if (!config::Manager::Instance()->Set(argc, argv))
67	{	68	{
68	CleanUp();	69	CleanUp();
69	return EXIT_SUCCESS;	70	return EXIT_SUCCESS;
70	}	71	}
71		72
72	if (config::Manager::Instance()->Exist("LogFile"))	73	if (config::Manager::Instance()->Exist("LogFile"))
73	{	74	{
74	logging::Logger::OpenFile(config::Manager::Instance()->GetAsString("LogFile"));	75	logging::Logger::OpenFile(config::Manager::Instance()->GetAsString("LogFile"));
75	}	76	}
76		77
77	if (config::Manager::Instance()->Exist("LogLevel"))	78	if (config::Manager::Instance()->Exist("LogLevel"))
78	{	79	{
79	logging::Logger::SetLevel((logging::Logger::Level)config::Manager::Instance()->GetAsInt("LogLevel"));	80	logging::Logger::SetLevel((logging::Logger::Level)config::Manager::Instance()->GetAsInt("LogLevel"));
80	}	81	}
81		82
82	if (config::Manager::Instance()->Exist("daemon"))	83	if (config::Manager::Instance()->Exist("daemon"))
83	{	84	{
84	LOG.Info("Entering daemon mode...");	85	LOG.Info("Entering daemon mode...");
85		86
86	if (daemon(0, 0) == -1)	87	if (daemon(0, 0) == -1)
87	{	88	{
88	LOG.Error("Could not enter daemon mode. Exiting...");	89	LOG.Error("Could not enter daemon mode. Exiting...");
89	CleanUp();	90	CleanUp();
90	return EXIT_FAILURE;	91	return EXIT_FAILURE;
91	}	92	}
92		93
93	LOG.Info("Deamon mode entered successfully!");	94	LOG.Info("Deamon mode entered successfully!");
94	}	95	}
95		96
96	timer::Manager::Create();	97	timer::Manager::Create();
97	broker::Manager::Create();	98	broker::Manager::Create();
98	net::Manager::Create();	99	net::Manager::Create();
99	can::Protocol::Create();	100	can::Protocol::Create();
100	can::Manager::Create();	101	can::Manager::Create();
101	vm::Manager::Create();	102	vm::Manager::Create();
102		103
103	if (config::Manager::Instance()->Exist("ProtocolFile"))	104	if (config::Manager::Instance()->Exist("ProtocolFile"))
104	{	105	{
105	can::Protocol::Instance()->Load(config::Manager::Instance()->GetAsString("ProtocolFile"));	106	can::Protocol::Instance()->Load(config::Manager::Instance()->GetAsString("ProtocolFile"));
106	}	107	}
107		108
108	if (config::Manager::Instance()->Exist("MonitorPort"))	109	if (config::Manager::Instance()->Exist("MonitorPort"))
109	{	110	{
110	subscribers.push_back(can::Monitor::Pointer(new can::Monitor(config::Manager::Instance()->GetAsInt("MonitorPort"))));	111	subscribers.push_back(can::Monitor::Pointer(new can::Monitor(config::Manager::Instance()->GetAsInt("MonitorPort"))));
111	}	112	}
112		113
113	subscribers.push_back(can::Manager::Instance());	114	subscribers.push_back(can::Manager::Instance());
114		115
115	if (config::Manager::Instance()->Exist("CanNet"))	116	if (config::Manager::Instance()->Exist("CanNet"))
116	{	117	{
117	type::StringList cannetworks = config::Manager::Instance()->GetAsStringVector("CanNet");	118	type::StringList cannetworks = config::Manager::Instance()->GetAsStringVector("CanNet");
118		119
119	for (int n = 0; n < cannetworks.size(); n++)	120	for (int n = 0; n < cannetworks.size(); n++)
120	{	121	{
121	subscribers.push_back(can::Network::Pointer(new can::Network(cannetworks[n])));	122	subscribers.push_back(can::Network::Pointer(new can::Network(cannetworks[n])));
122	}	123	}
123	}	124	}
124		125
125	vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::System()));	126	vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::System()));
126	vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::Timer()));	127	vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::Timer()));
-		128	vm::Manager::Instance()->AddPlugin(vm::Plugin::Pointer(new vm::plugin::Module()));
127		129
128	if (config::Manager::Instance()->Exist("ScriptPath"))	130	if (config::Manager::Instance()->Exist("ScriptPath"))
129	{	131	{
130	vm::Manager::Instance()->Start(config::Manager::Instance()->GetAsString("ScriptPath"));	132	vm::Manager::Instance()->Start(config::Manager::Instance()->GetAsString("ScriptPath"));
131	}	133	}
132		134
133	LOG.Info("Initialization complete.");	135	LOG.Info("Initialization complete.");
134		136
135	boost::mutex::scoped_lock guard(guard_mutex);	137	boost::mutex::scoped_lock guard(guard_mutex);
136	on_message_condition.wait(guard);	138	on_message_condition.wait(guard);
137		139
138	LOG.Info("Cleaning up...");	140	LOG.Info("Cleaning up...");
139		141
140	CleanUp();	142	CleanUp();
141		143
142	LOG.Info("Thank you for using Atom. Goodbye!");	144	LOG.Info("Thank you for using Atom. Goodbye!");
143		145
144	return EXIT_SUCCESS;	146	return EXIT_SUCCESS;
145	}	147	}
146		148
147	void CleanUp()	149	void CleanUp()
148	{	150	{
149	subscribers.clear();	151	subscribers.clear();
150	vm::Manager::Delete();	-
151	config::Manager::Delete();	152	config::Manager::Delete();
152	timer::Manager::Delete();	153	timer::Manager::Delete();
153	can::Manager::Delete();	154	can::Manager::Delete();
-		155	vm::Manager::Delete();
154	can::Protocol::Delete();	156	can::Protocol::Delete();
155	broker::Manager::Delete();	157	broker::Manager::Delete();
156	net::Manager::Delete();	158	net::Manager::Delete();
157	}	159	}
158		160
159	void Handler(int status)	161	void Handler(int status)
160	{	162	{
161	std::string signal_name = "Unknown";	163	std::string signal_name = "Unknown";
162		164
163	switch (status)	165	switch (status)
164	{	166	{
165	case SIGTERM:	167	case SIGTERM:
166	{	168	{
167	signal_name = "Terminate";	169	signal_name = "Terminate";
168	break;	170	break;
169	}	171	}
170	case SIGINT:	172	case SIGINT:
171	{	173	{
172	signal_name = "Interupt";	174	signal_name = "Interupt";
173	break;	175	break;
174	}	176	}
175	case SIGQUIT:	177	case SIGQUIT:
176	{	178	{
177	signal_name = "Quit";	179	signal_name = "Quit";
178	break;	180	break;
179	}	181	}
180	case SIGABRT:	182	case SIGABRT:
181	{	183	{
182	signal_name = "Abort";	184	signal_name = "Abort";
183	break;	185	break;
184	}	186	}
185	case SIGIO:	187	case SIGIO:
186	{	188	{
187	signal_name = "I/O";	189	signal_name = "I/O";
188	break;	190	break;
189	}	191	}
190	case SIGPIPE:	192	case SIGPIPE:
191	{	193	{
192	signal_name = "Pipe";	194	signal_name = "Pipe";
193	break;	195	break;
194	}	196	}
195	}	197	}
196		198
197	LOG.Debug("Received signal " + signal_name + "(" + boost::lexical_cast<std::string>(status) + ").");	199	LOG.Debug("Received signal " + signal_name + "(" + boost::lexical_cast<std::string>(status) + ").");
198		200
199	if (status != SIGPIPE)	201	if (status != SIGPIPE)
200	{	202	{
201	on_message_condition.notify_all();	203	on_message_condition.notify_all();
202	}	204	}
203	}	205	}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/main.cpp @ 1602 – Rev 1601 → 1602