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()
{
        std::map<std::string, Task*>::iterator it;
        for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
        {
                delete it->second;
        }
        _persistant_tasks.clear();
}

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