--- smsdaemon/TaskManager.cpp	2008/06/15 20:06:39	82
+++ smsdaemon/TaskManager.cpp	2009/04/10 20:11:21	223
@@ -1,67 +1,181 @@
-	
+
 #include "TaskManager.h"
 
-#include "common.h"
+#include "Logger.h"
+#include "Common.h"
+#include "Util.h"
+#include "ConfigFile.h"
 
 #include <time.h>
 
+#include "tasks/SpoolTask.h"
+
+
 TaskManager::TaskManager()
- : _lastExecuted(0)
+		: _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);
+	}
 }
 
-
-void TaskManager::LoadTasks()
+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::ExecuteTasks()
+void TaskManager::LoadTasks()
 {
-	int now = time(0);
 
-	if (now > _lastExecuted) // only execute the tasks once every second
+	Logger::logMessage("--------  TaskList  --------");
+	std::vector<Value> tasklist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "task");
+
+	for (unsigned i=0; i<tasklist.size(); i++)
 	{
-		_lastExecuted = now;
+		std::string current = tasklist[i];
+
+		std::string name;
+		unsigned pos = current.find(' ');
+		std::map<std::string,std::string> args;
 
-		std::map<std::string, Task*>::iterator it;
+		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);
+		}
 
-		for (it = _tasks.begin(); it != _tasks.end(); ++it)
+		Task* task = 0;
+		try
 		{
-			Task* tsk = (*it).second;
-			tsk->ExecuteTask();
+			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() + "\"" );
 	}
 }
 
 
-Task* TaskManager::GetTask(const std::string& taskname)
+void TaskManager::AddPersistantTask(Task* task)
 {
-	return _tasks[ taskname ];
+
+	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);
 }
 
 
-std::vector<Task*> TaskManager::GetTaskList()
+void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
 {
-	typedef std::map<std::string, Task*>::iterator MapIterator;
-	std::vector<Task*> task_list;
+	const int SLEEP_TIME = 2; //wait this long between task executions
+	int now = time(0);
+
+	if (now < (_lastExecuted + SLEEP_TIME) )
+		return;
+
+	_lastExecuted = now;
 
-	for (MapIterator it = _tasks.begin(); it != _tasks.end(); ++it)
+	//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* pl = (*it).second;
-		task_list.push_back(pl);
+		Task* tsk = (*m_it).second;
+		tsk->ExecuteTask(modem);
 	}
 
+	//execute temporary tasks
 
-	return task_list;
-}
+	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)
+{
+	std::map<std::string, Task*>::iterator it;
+	it = _persistant_tasks.find(taskname);
+	if (it != _persistant_tasks.end())
+		return it->second;
+	else
+		return 0;
+}
+