/[projects]/smsdaemon/TaskManager.cpp
ViewVC logotype

Diff of /smsdaemon/TaskManager.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 92 by torben, Mon Jun 16 11:30:20 2008 UTC revision 223 by torben, Fri Apr 10 20:11:21 2009 UTC
# Line 1  Line 1 
1            
2  #include "TaskManager.h"  #include "TaskManager.h"
3    
4  #include "common.h"  #include "Logger.h"
5    #include "Common.h"
6    #include "Util.h"
7    #include "ConfigFile.h"
8    
9  #include <time.h>  #include <time.h>
10    
11    #include "tasks/SpoolTask.h"
12    
13    
14  TaskManager::TaskManager()  TaskManager::TaskManager()
15   : _lastExecuted(0)                  : _lastExecuted(0)
16  {  {
17  }  }
18            
19  TaskManager::~TaskManager()  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)
 void TaskManager::LoadTasks()  
30  {  {
31            if (taskName =="spool")
32                    return new SpoolTask();
33    
34            return 0;
35  }  }
36    
37    void TaskManager::DestroyTasks()
38    {
39            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    }
46    
47  void TaskManager::ExecuteTasks(IGsmModem& modem)  void TaskManager::LoadTasks()
48  {  {
         const int SLEEP_TIME = 10; //wait at least 10 seconds between executions  
         int now = time(0);  
49    
50          if (now > (_lastExecuted + SLEEP_TIME) )          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                  _lastExecuted = now;                  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::map<std::string, Task*>::iterator it;                  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                  for (it = _tasks.begin(); it != _tasks.end(); ++it)                  Task* task = 0;
75                    try
76                  {                  {
77                          Task* tsk = (*it).second;                          task = CreateTask(name, args );
                         tsk->ExecuteTask(modem);  
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            //print the loaded tasks
94            std::map<std::string, Task*>::iterator it;
95            for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
96            {
97                    Task* tsk = (*it).second;
98                    if (tsk != 0)
99                            Logger::logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
100          }          }
101  }  }
102    
103    
104  Task* TaskManager::GetTask(const std::string& taskname)  void TaskManager::AddPersistantTask(Task* task)
105  {  {
106          return _tasks[ taskname ];  
107            if (task != 0)
108            {
109                    std::string name = task->GetName();
110    
111                    if ( _persistant_tasks[ name ] == 0)
112                            _persistant_tasks[ name ] = task;
113                    else
114                            Logger::logMessage( std::string("AddTask() -- already have a task called ") + name);
115            }
116            else
117            {
118                    Logger::logMessage("AddTask() -- cannot register a null pointer");
119            }
120    }
121    
122    void TaskManager::AddTemporaryTask(Task* task)
123    {
124            _temp_tasks.push_back(task);
125  }  }
126    
127    
128  std::vector<Task*> TaskManager::GetTaskList()  void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
129  {  {
130          typedef std::map<std::string, Task*>::iterator MapIterator;          const int SLEEP_TIME = 2; //wait this long between task executions
131          std::vector<Task*> task_list;          int now = time(0);
132    
133            if (now < (_lastExecuted + SLEEP_TIME) )
134                    return;
135    
136            _lastExecuted = now;
137    
138          for (MapIterator it = _tasks.begin(); it != _tasks.end(); ++it)          //execute real tasks
139    
140            std::map<std::string, Task*>::iterator m_it;
141    
142            for (m_it = _persistant_tasks.begin(); m_it != _persistant_tasks.end(); ++m_it)
143          {          {
144                  Task* pl = (*it).second;                  Task* tsk = (*m_it).second;
145                  task_list.push_back(pl);                  tsk->ExecuteTask(modem);
146          }          }
147    
148            //execute temporary tasks
149    
150          return task_list;          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                            l_it = _temp_tasks.erase(l_it);
160    
161                            //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                            --l_it;
164                    }
165            }
166    
167    
168    }
169    
170    
171    Task* TaskManager::GetPersistantTask(const std::string& taskname)
172    {
173            std::map<std::string, Task*>::iterator it;
174            it = _persistant_tasks.find(taskname);
175            if (it != _persistant_tasks.end())
176                    return it->second;
177            else
178                    return 0;
179    }
180    
181    
Legend:
Removed from v.92  
changed lines
  Added in v.223
  ViewVC Help
Powered by ViewVC 1.1.20