projects/smsdaemon/TaskManager.cpp


#include "TaskManager.h"

#include "Logger.h"
#include "Common.h"
#include "Util.h"
#include "ConfigFile.h"

#include <time.h>

#include "tasks/SpoolTask.h"


TaskManager::TaskManager()
                : _lastExecuted(0)
{
}

TaskManager::~TaskManager()
{
        //delete any temporary tasks still in the list
        std::list<Task*>::iterator it;
        for (it = _temp_tasks.begin(); it != _temp_tasks.end(); ++it)
        {
                delete (*it);
        }
}

Task* TaskManager::CreateTask(const std::string& taskName, const std::map<std::string, std::string>& arguments)
{
        if (taskName =="spool")
                return new SpoolTask();

        return 0;
}

void TaskManager::DestroyTasks()
{
}

void TaskManager::LoadTasks()
{

        Logger::logMessage("--------  TaskList  --------");
        std::vector<Value> tasklist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "task");

        for (unsigned i=0; i<tasklist.size(); i++)
        {
                std::string current = tasklist[i];

                std::string name;
                unsigned pos = current.find(' ');
                std::map<std::string,std::string> args;

                std::string argstr;

                if (pos == std::string::npos)
                {
                        name = current;
                }
                else
                {
                        name = Util::str_trim(current.substr(0,pos));
                        argstr = Util::str_trim(current.substr(pos+1,1024));
                        args = ConfigHelper::ParseArguments(argstr);
                }

                Task* task = 0;
                try
                {
                        task = CreateTask(name, args );
                }
                catch (std::exception& e)
                {
                        Logger::logMessage(std::string("Failed to load task ") + name + " with args: " + argstr);
                        Logger::logMessage(std::string("Reason: ") + e.what());
                        continue;
                }

                if (task)
                        AddPersistantTask(task);
                else
                        Logger::logMessage( std::string("Unknown task: ")+name);

        }

        //print the loaded tasks
        std::map<std::string, Task*>::iterator it;
        for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
        {
                Task* tsk = (*it).second;
                if (tsk != 0)
                        Logger::logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
        }
}


void TaskManager::AddPersistantTask(Task* task)
{

        if (task != 0)
        {
                std::string name = task->GetName();

                if ( _persistant_tasks[ name ] == 0)
                        _persistant_tasks[ name ] = task;
                else
                        Logger::logMessage( std::string("AddTask() -- already have a task called ") + name);
        }
        else
        {
                Logger::logMessage("AddTask() -- cannot register a null pointer");
        }
}

void TaskManager::AddTemporaryTask(Task* task)
{
        _temp_tasks.push_back(task);
}


void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
{
        const int SLEEP_TIME = 2; //wait this long between task executions
        int now = time(0);

        if (now < (_lastExecuted + SLEEP_TIME) )
                return;

        _lastExecuted = now;

        //execute real tasks

        std::map<std::string, Task*>::iterator m_it;

        for (m_it = _persistant_tasks.begin(); m_it != _persistant_tasks.end(); ++m_it)
        {
                Task* tsk = (*m_it).second;
                tsk->ExecuteTask(modem);
        }

        //execute temporary tasks

        std::list<Task*>::iterator l_it;
        for (l_it = _temp_tasks.begin(); l_it != _temp_tasks.end(); ++l_it)
        {
                Task* tsk = (*l_it);
                tsk->ExecuteTask(modem);

                if ( tsk->IsFinished() )
                {
                        delete tsk;
                        l_it = _temp_tasks.erase(l_it);

                        //now l_it points to the next element in the list,
                        //but since the for() loop will increment it before next iteration we will decrease it here
                        --l_it;
                }
        }


}


Task* TaskManager::GetPersistantTask(const std::string& taskname)
{
        return _persistant_tasks[ taskname ];
}
1
2	#include "TaskManager.h"
3
4	#include "Logger.h"
5	#include "Common.h"
6	#include "Util.h"
7	#include "ConfigFile.h"
8
9	#include <time.h>
10
11	#include "tasks/SpoolTask.h"
12
13
14	TaskManager::TaskManager()
15	: _lastExecuted(0)
16	{
17	}
18
19	TaskManager::~TaskManager()
20	{
21	//delete any temporary tasks still in the list
22	std::list<Task*>::iterator it;
23	for (it = _temp_tasks.begin(); it != _temp_tasks.end(); ++it)
24	{
25	delete (*it);
26	}
27	}
28
29	Task* TaskManager::CreateTask(const std::string& taskName, const std::map<std::string, std::string>& arguments)
30	{
31	if (taskName =="spool")
32	return new SpoolTask();
33
34	return 0;
35	}
36
37	void TaskManager::DestroyTasks()
38	{
39	}
40
41	void TaskManager::LoadTasks()
42	{
43
44	Logger::logMessage("-------- TaskList --------");
45	std::vector<Value> tasklist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "task");
46
47	for (unsigned i=0; i<tasklist.size(); i++)
48	{
49	std::string current = tasklist[i];
50
51	std::string name;
52	unsigned pos = current.find(' ');
53	std::map<std::string,std::string> args;
54
55	std::string argstr;
56
57	if (pos == std::string::npos)
58	{
59	name = current;
60	}
61	else
62	{
63	name = Util::str_trim(current.substr(0,pos));
64	argstr = Util::str_trim(current.substr(pos+1,1024));
65	args = ConfigHelper::ParseArguments(argstr);
66	}
67
68	Task* task = 0;
69	try
70	{
71	task = CreateTask(name, args );
72	}
73	catch (std::exception& e)
74	{
75	Logger::logMessage(std::string("Failed to load task ") + name + " with args: " + argstr);
76	Logger::logMessage(std::string("Reason: ") + e.what());
77	continue;
78	}
79
80	if (task)
81	AddPersistantTask(task);
82	else
83	Logger::logMessage( std::string("Unknown task: ")+name);
84
85	}
86
87	//print the loaded tasks
88	std::map<std::string, Task*>::iterator it;
89	for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
90	{
91	Task* tsk = (*it).second;
92	if (tsk != 0)
93	Logger::logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
94	}
95	}
96
97
98	void TaskManager::AddPersistantTask(Task* task)
99	{
100
101	if (task != 0)
102	{
103	std::string name = task->GetName();
104
105	if ( _persistant_tasks[ name ] == 0)
106	_persistant_tasks[ name ] = task;
107	else
108	Logger::logMessage( std::string("AddTask() -- already have a task called ") + name);
109	}
110	else
111	{
112	Logger::logMessage("AddTask() -- cannot register a null pointer");
113	}
114	}
115
116	void TaskManager::AddTemporaryTask(Task* task)
117	{
118	_temp_tasks.push_back(task);
119	}
120
121
122	void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
123	{
124	const int SLEEP_TIME = 2; //wait this long between task executions
125	int now = time(0);
126
127	if (now < (_lastExecuted + SLEEP_TIME) )
128	return;
129
130	_lastExecuted = now;
131
132	//execute real tasks
133
134	std::map<std::string, Task*>::iterator m_it;
135
136	for (m_it = _persistant_tasks.begin(); m_it != _persistant_tasks.end(); ++m_it)
137	{
138	Task* tsk = (*m_it).second;
139	tsk->ExecuteTask(modem);
140	}
141
142	//execute temporary tasks
143
144	std::list<Task*>::iterator l_it;
145	for (l_it = _temp_tasks.begin(); l_it != _temp_tasks.end(); ++l_it)
146	{
147	Task* tsk = (*l_it);
148	tsk->ExecuteTask(modem);
149
150	if ( tsk->IsFinished() )
151	{
152	delete tsk;
153	l_it = _temp_tasks.erase(l_it);
154
155	//now l_it points to the next element in the list,
156	//but since the for() loop will increment it before next iteration we will decrease it here
157	--l_it;
158	}
159	}
160
161
162	}
163
164
165	Task* TaskManager::GetPersistantTask(const std::string& taskname)
166	{
167	return _persistant_tasks[ taskname ];
168	}