projects/smsdaemon/PluginManager.cpp

#include "PluginManager.h"

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

#include "plugins/EchoPlugin.h"
#include "plugins/SpamPlugin.h"
#include "plugins/ShellExecPlugin.h"
#include "plugins/TogPlugin.h"
#include "plugins/StatusPlugin.h"
#include "plugins/ListPlugin.h"
#include "plugins/HostStatusPlugin.h"
#include "plugins/WeatherPlugin.h"
#include "plugins/UrlTriggerPlugin.h"

typedef std::map<std::string, Plugin*>::iterator MapIterator;

PluginManager::PluginManager()
{
}

PluginManager::~PluginManager()
{
}


void PluginManager::AddPlugin(Plugin* plugin)
{
        if (plugin != 0)
        {
                if (plugin->IsHelper())
                {
                        _helper_plugins.push_back(plugin);
                }
                else
                {
                        std::string command = plugin->GetCommand();

                        if ( _plugins[ command ] == 0)
                                _plugins[ command ] = plugin;
                        else
                                Logger::logMessage( std::string("AddPlugin() -- already have a plugin called ") + command);
                }
        }
        else
        {
                Logger::logMessage("AddPlugin() -- cannot register a null pointer");
        }
}

Plugin* PluginManager::CreatePlugin(const std::string& pluginName, const std::map<std::string,std::string>& args)
{
        if (pluginName == "echo")
                return new EchoPlugin();

        if (pluginName == "spam")
                return new SpamPlugin();

        if (pluginName == "tog")
                return new TogPlugin();

        if (pluginName == "status")
                return new StatusPlugin();

        if (pluginName == "list")
                return new ListPlugin();

        if (pluginName == "hoststatus")
                return new HostStatusPlugin();

        if (pluginName == "weather")
                return new WeatherPlugin();

        if (pluginName == "shellexec")
                return new ShellExecPlugin(args);

        if (pluginName == "urltrigger")
                return new UrlTriggerPlugin(args);
        
        return 0;
}

void PluginManager::LoadPlugins()
{
/*

        static ShellExecPlugin wake("wake", "/usr/local/bin/wake", false, false);
        static ShellExecPlugin ping("ping", "nmap -sP 192.168.10.1-255 | grep appears | awk '{print $2}'", false,true);


        static UrlTriggerPlugin urltrigger("tou", "http://t-hoerup.dk/test.php");
*/

        Logger::logMessage("-------- PluginList --------");
        std::vector<Value> pluginlist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "plugin");

        for (unsigned i=0; i<pluginlist.size(); i++) 
        {
                std::string current = pluginlist[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);
                }

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

                if (pl)
                        AddPlugin(pl);
                else
                        Logger::logMessage( std::string("Unknown plugin: ")+name);
                
        }       


        for (MapIterator it = _plugins.begin(); it != _plugins.end(); ++it)
        {
                Plugin* pl = (*it).second;
                if (pl != 0)
                        Logger::logMessage( std::string("Loaded plugin \"") + pl->GetCommand() + "\" - " + pl->GetDescription() );
        }
}

void PluginManager::DestroyPlugins()
{
}

Plugin* PluginManager::GetPlugin(const std::string& pluginname)
{
        return _plugins[ pluginname ];
}


std::vector<Plugin*> PluginManager::GetPluginList()
{
        typedef std::map<std::string, Plugin*>::iterator MapIterator;
        std::vector<Plugin*> plugin_list;

        for (MapIterator it = _plugins.begin(); it != _plugins.end(); ++it)
        {
                Plugin* pl = (*it).second;
                plugin_list.push_back(pl);
        }


        return plugin_list;
}
1	torben	26	#include "PluginManager.h"
2
3	torben	157	#include "Logger.h"
4	torben	205	#include "ConfigFile.h"
5			#include "Common.h"
6			#include "Util.h"
7	torben	26
8	torben	132	#include "plugins/EchoPlugin.h"
9			#include "plugins/SpamPlugin.h"
10			#include "plugins/ShellExecPlugin.h"
11			#include "plugins/TogPlugin.h"
12			#include "plugins/StatusPlugin.h"
13			#include "plugins/ListPlugin.h"
14	torben	137	#include "plugins/HostStatusPlugin.h"
15	torben	188	#include "plugins/WeatherPlugin.h"
16	torben	193	#include "plugins/UrlTriggerPlugin.h"
17	torben	26
18			typedef std::map<std::string, Plugin*>::iterator MapIterator;
19
20			PluginManager::PluginManager()
21			{
22			}
23	torben	196
24	torben	26	PluginManager::~PluginManager()
25			{
26			}
27
28
29	torben	28	void PluginManager::AddPlugin(Plugin* plugin)
30			{
31	torben	35	if (plugin != 0)
32			{
33	torben	184	if (plugin->IsHelper())
34			{
35			_helper_plugins.push_back(plugin);
36			}
37			else
38			{
39			std::string command = plugin->GetCommand();
40	torben	35
41	torben	184	if ( _plugins[ command ] == 0)
42			_plugins[ command ] = plugin;
43			else
44			Logger::logMessage( std::string("AddPlugin() -- already have a plugin called ") + command);
45			}
46	torben	35	}
47			else
48			{
49	torben	157	Logger::logMessage("AddPlugin() -- cannot register a null pointer");
50	torben	35	}
51	torben	28	}
52
53	torben	205	Plugin* PluginManager::CreatePlugin(const std::string& pluginName, const std::map<std::string,std::string>& args)
54			{
55			if (pluginName == "echo")
56			return new EchoPlugin();
57
58			if (pluginName == "spam")
59			return new SpamPlugin();
60
61			if (pluginName == "tog")
62			return new TogPlugin();
63
64			if (pluginName == "status")
65			return new StatusPlugin();
66
67			if (pluginName == "list")
68			return new ListPlugin();
69
70			if (pluginName == "hoststatus")
71			return new HostStatusPlugin();
72
73			if (pluginName == "weather")
74			return new WeatherPlugin();
75
76			if (pluginName == "shellexec")
77			return new ShellExecPlugin(args);
78
79			if (pluginName == "urltrigger")
80			return new UrlTriggerPlugin(args);
81
82			return 0;
83			}
84
85	torben	26	void PluginManager::LoadPlugins()
86			{
87	torben	205	/*
88	torben	28
89	torben	203	static ShellExecPlugin wake("wake", "/usr/local/bin/wake", false, false);
90	torben	107	static ShellExecPlugin ping("ping", "nmap -sP 192.168.10.1-255 \| grep appears \| awk '{print $2}'", false,true);
91	torben	35
92	torben	49
93	torben	101
94	torben	114
95	torben	205	static UrlTriggerPlugin urltrigger("tou", "http://t-hoerup.dk/test.php");
96			*/
97	torben	137
98	torben	207	Logger::logMessage("-------- PluginList --------");
99	torben	205	std::vector<Value> pluginlist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "plugin");
100	torben	188
101	torben	205	for (unsigned i=0; i<pluginlist.size(); i++)
102			{
103			std::string current = pluginlist[i];
104
105			std::string name;
106			unsigned pos = current.find(' ');
107			std::map<std::string,std::string> args;
108	torben	193
109	torben	205	std::string argstr;
110
111			if (pos == std::string::npos)
112			{
113			name = current;
114			}
115			else
116			{
117			name = Util::str_trim(current.substr(0,pos));
118			argstr = Util::str_trim(current.substr(pos+1,1024));
119			args = ConfigHelper::ParseArguments(argstr);
120			}
121
122			Plugin* pl = 0;
123			try
124			{
125			pl = CreatePlugin(name, args );
126			}
127			catch (std::exception& e)
128			{
129			Logger::logMessage(std::string("Failed to load plugin ") + name + " with args: " + argstr);
130			Logger::logMessage(std::string("Reason: ") + e.what());
131			continue;
132			}
133
134			if (pl)
135			AddPlugin(pl);
136			else
137			Logger::logMessage( std::string("Unknown plugin: ")+name);
138
139			}
140
141
142	torben	196	for (MapIterator it = _plugins.begin(); it != _plugins.end(); ++it)
143	torben	26	{
144			Plugin* pl = (*it).second;
145	torben	35	if (pl != 0)
146	torben	157	Logger::logMessage( std::string("Loaded plugin \"") + pl->GetCommand() + "\" - " + pl->GetDescription() );
147	torben	26	}
148			}
149
150	torben	205	void PluginManager::DestroyPlugins()
151			{
152			}
153
154	torben	26	Plugin* PluginManager::GetPlugin(const std::string& pluginname)
155			{
156			return _plugins[ pluginname ];
157			}
158
159
160			std::vector<Plugin*> PluginManager::GetPluginList()
161			{
162			typedef std::map<std::string, Plugin*>::iterator MapIterator;
163			std::vector<Plugin*> plugin_list;
164
165			for (MapIterator it = _plugins.begin(); it != _plugins.end(); ++it)
166			{
167			Plugin* pl = (*it).second;
168			plugin_list.push_back(pl);
169			}
170
171
172			return plugin_list;
173			}