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");
*/

        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
2	#include "PluginManager.h"
3
4	#include "Logger.h"
5	#include "ConfigFile.h"
6	#include "Common.h"
7	#include "Util.h"
8
9	#include "plugins/EchoPlugin.h"
10	#include "plugins/SpamPlugin.h"
11	#include "plugins/ShellExecPlugin.h"
12	#include "plugins/TogPlugin.h"
13	#include "plugins/StatusPlugin.h"
14	#include "plugins/ListPlugin.h"
15	#include "plugins/HostStatusPlugin.h"
16	#include "plugins/WeatherPlugin.h"
17	#include "plugins/UrlTriggerPlugin.h"
18
19	typedef std::map<std::string, Plugin*>::iterator MapIterator;
20
21	PluginManager::PluginManager()
22	{
23	}
24
25	PluginManager::~PluginManager()
26	{
27	}
28
29
30	void PluginManager::AddPlugin(Plugin* plugin)
31	{
32	if (plugin != 0)
33	{
34	if (plugin->IsHelper())
35	{
36	_helper_plugins.push_back(plugin);
37	}
38	else
39	{
40	std::string command = plugin->GetCommand();
41
42	if ( _plugins[ command ] == 0)
43	_plugins[ command ] = plugin;
44	else
45	Logger::logMessage( std::string("AddPlugin() -- already have a plugin called ") + command);
46	}
47	}
48	else
49	{
50	Logger::logMessage("AddPlugin() -- cannot register a null pointer");
51	}
52	}
53
54	Plugin* PluginManager::CreatePlugin(const std::string& pluginName, const std::map<std::string,std::string>& args)
55	{
56	if (pluginName == "echo")
57	return new EchoPlugin();
58
59	if (pluginName == "spam")
60	return new SpamPlugin();
61
62	if (pluginName == "tog")
63	return new TogPlugin();
64
65	if (pluginName == "status")
66	return new StatusPlugin();
67
68	if (pluginName == "list")
69	return new ListPlugin();
70
71	if (pluginName == "hoststatus")
72	return new HostStatusPlugin();
73
74	if (pluginName == "weather")
75	return new WeatherPlugin();
76
77	if (pluginName == "shellexec")
78	return new ShellExecPlugin(args);
79
80	if (pluginName == "urltrigger")
81	return new UrlTriggerPlugin(args);
82
83	return 0;
84	}
85
86	void PluginManager::LoadPlugins()
87	{
88	/*
89
90	static ShellExecPlugin wake("wake", "/usr/local/bin/wake", false, false);
91	static ShellExecPlugin ping("ping", "nmap -sP 192.168.10.1-255 \| grep appears \| awk '{print $2}'", false,true);
92
93
94
95
96	static UrlTriggerPlugin urltrigger("tou", "http://t-hoerup.dk/test.php");
97	*/
98
99	std::vector<Value> pluginlist = Common::instance()->GetConfigfile()->GetValues("smsdaemon", "plugin");
100
101	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
109	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
143	for (MapIterator it = _plugins.begin(); it != _plugins.end(); ++it)
144	{
145	Plugin* pl = (*it).second;
146	if (pl != 0)
147	Logger::logMessage( std::string("Loaded plugin \"") + pl->GetCommand() + "\" - " + pl->GetDescription() );
148	}
149	}
150
151	void PluginManager::DestroyPlugins()
152	{
153	}
154
155	Plugin* PluginManager::GetPlugin(const std::string& pluginname)
156	{
157	return _plugins[ pluginname ];
158	}
159
160
161	std::vector<Plugin*> PluginManager::GetPluginList()
162	{
163	typedef std::map<std::string, Plugin*>::iterator MapIterator;
164	std::vector<Plugin*> plugin_list;
165
166	for (MapIterator it = _plugins.begin(); it != _plugins.end(); ++it)
167	{
168	Plugin* pl = (*it).second;
169	plugin_list.push_back(pl);
170	}
171
172
173	return plugin_list;
174	}