projects/smsdaemon/Common.cpp

#include "Common.h"


#include "version.h"

#include <stdlib.h>
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <time.h>

#include "TaskManager.h"
#include "PluginManager.h"
#include "ConfigFile.h"

using namespace std;

Common* Common::instance()
{
        static Common store;
        return &store;
}


Common::Common()
                : _pluginManager(0), _taskManager(0)
{
        _pluginManager = new PluginManager();
        _taskManager = new TaskManager();
        configFilePath = "/etc/smsdaemon.conf";
        _configFile = new ConfigFile();

        daemonized = false;
        reloadConfig = false;
}


Common::~Common()
{
        if (_pluginManager)
                delete _pluginManager;

        if (_taskManager)
                delete _taskManager;
}

PluginManager* Common::GetPluginManager()
{
        return _pluginManager;
}

TaskManager* Common::GetTaskManager()
{
        return _taskManager;
}

ConfigFile* Common::GetConfigfile()
{
        return _configFile;
}


void Common::printUsage()
{
        cout << VERSION << endl;
        cout << SVNVERSION << endl << endl;
        cout << "Usage --daemon|--debug [arguments]" << endl;
        cout << "Commandline arguments :" << endl;
        cout << "  --daemon :       Run in daemon (background) mode" << endl;
        cout << "  --debug :        Run as normal (frontground) process," << endl;
        cout << "                   with all messages written to std out" << endl;
        cout << "  --config <file>: Specify which config file to use " << endl;
        cout << "                   default" << configFilePath << endl;
        cout << "  --help :         Show this help screen" << endl;

        exit(0);
}

void Common::loadConfig(int argc, char* argv[])
{
        isDaemon = false;
        isDebug = false;

        for (int i = 1; i< argc; i++)
        {
                string current(argv[i]);
                if (current == "--daemon")
                {
                        isDaemon = true;
                        isDebug = false;

                }
                else if (current == "--debug")
                {
                        isDaemon = false;
                        isDebug = true;
                }
                else if (current == "--config")
                {
                        i++;
                        if ( i<argc)
                        {
                                configFilePath = argv[i];
                        }
                        else
                        {
                                printUsage();
                                exit(1);
                        }

                }
                else if (current == "-h" || current == "--help")
                {
                        printUsage();
                }
                else
                {
                        cout << "Unknown argument : " << current << endl << endl;
                }
        }

        if (! ( isDaemon || isDebug))
                printUsage();
}


std::string Common::getStatusMessage()
{
        long int now = time(0);

        long int diff = now - this->daemonStart;


        std::ostringstream out;
        out << "Uptime " << diff << " seconds. ";
        out << "Messages received:" << this->smsCounter.incomming << ". ";
        out << "Messages sent:" << this->smsCounter.outgoing << ".";

        return out.str();
}
1	#include "Common.h"
2
3
4	#include "version.h"
5
6	#include <stdlib.h>
7	#include <string>
8	#include <iostream>
9	#include <iomanip>
10	#include <sstream>
11	#include <time.h>
12
13	#include "TaskManager.h"
14	#include "PluginManager.h"
15	#include "ConfigFile.h"
16
17	using namespace std;
18
19	Common* Common::instance()
20	{
21	static Common store;
22	return &store;
23	}
24
25
26	Common::Common()
27	: _pluginManager(0), _taskManager(0)
28	{
29	_pluginManager = new PluginManager();
30	_taskManager = new TaskManager();
31	configFilePath = "/etc/smsdaemon.conf";
32	_configFile = new ConfigFile();
33
34	daemonized = false;
35	reloadConfig = false;
36	}
37
38
39	Common::~Common()
40	{
41	if (_pluginManager)
42	delete _pluginManager;
43
44	if (_taskManager)
45	delete _taskManager;
46	}
47
48	PluginManager* Common::GetPluginManager()
49	{
50	return _pluginManager;
51	}
52
53	TaskManager* Common::GetTaskManager()
54	{
55	return _taskManager;
56	}
57
58	ConfigFile* Common::GetConfigfile()
59	{
60	return _configFile;
61	}
62
63
64	void Common::printUsage()
65	{
66	cout << VERSION << endl;
67	cout << SVNVERSION << endl << endl;
68	cout << "Usage --daemon\|--debug [arguments]" << endl;
69	cout << "Commandline arguments :" << endl;
70	cout << " --daemon : Run in daemon (background) mode" << endl;
71	cout << " --debug : Run as normal (frontground) process," << endl;
72	cout << " with all messages written to std out" << endl;
73	cout << " --config <file>: Specify which config file to use " << endl;
74	cout << " default" << configFilePath << endl;
75	cout << " --help : Show this help screen" << endl;
76
77	exit(0);
78	}
79
80	void Common::loadConfig(int argc, char* argv[])
81	{
82	isDaemon = false;
83	isDebug = false;
84
85	for (int i = 1; i< argc; i++)
86	{
87	string current(argv[i]);
88	if (current == "--daemon")
89	{
90	isDaemon = true;
91	isDebug = false;
92
93	}
94	else if (current == "--debug")
95	{
96	isDaemon = false;
97	isDebug = true;
98	}
99	else if (current == "--config")
100	{
101	i++;
102	if ( i<argc)
103	{
104	configFilePath = argv[i];
105	}
106	else
107	{
108	printUsage();
109	exit(1);
110	}
111
112	}
113	else if (current == "-h" \|\| current == "--help")
114	{
115	printUsage();
116	}
117	else
118	{
119	cout << "Unknown argument : " << current << endl << endl;
120	}
121	}
122
123	if (! ( isDaemon \|\| isDebug))
124	printUsage();
125	}
126
127
128	std::string Common::getStatusMessage()
129	{
130	long int now = time(0);
131
132	long int diff = now - this->daemonStart;
133
134
135	std::ostringstream out;
136	out << "Uptime " << diff << " seconds. ";
137	out << "Messages received:" << this->smsCounter.incomming << ". ";
138	out << "Messages sent:" << this->smsCounter.outgoing << ".";
139
140	return out.str();
141	}