1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
PluginManager.h - header file for plugin manager. it takes care about
(un)loading plugins
Copyright (C) 2009 Zdenek Prikryl (zprikryl@redhat.com)
Copyright (C) 2009 RedHat inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef PLUGINMANAGER_H_
#define PLUGINMANAGER_H_
#include "abrt_types.h"
#include "ABRTPlugin.h"
#include "Plugin.h"
#include "Analyzer.h"
#include "Reporter.h"
#include "Database.h"
#include "Action.h"
/**
* A class. It takes care of loading, registering and manipulating with
* plugins. When a plugin is loaded, its library is opened, but no plugin
* instance is created. It is possible after plugin registration.
*/
class CPluginManager
{
private:
typedef std::map<std::string, CABRTPlugin*> map_abrt_plugins_t;
typedef std::map<std::string, CPlugin*> map_plugins_t;
/**
* Loaded plugins. A key is a plugin name.
*/
map_abrt_plugins_t m_mapABRTPlugins;
/**
* Registered plugins. A key is a plugin name.
*/
map_plugins_t m_mapPlugins;
public:
/**
* A constructor.
* @param pPluginsConfDir A plugins configuration directory.
* @param pPluginsLibDir A plugins library directory.
*/
CPluginManager();
/**
* A destructor.
*/
~CPluginManager();
/**
* A method, which loads all plugins in plugins library direcotry.
*/
void LoadPlugins();
/**
* A method, which unregister and unload all loaded plugins.
*/
void UnLoadPlugins();
/**
* A method, which loads particular plugin.
* @param pName A plugin name.
*/
void LoadPlugin(const std::string& pName);
/**
* A method, which unloads particular plugin.
* @param pName A plugin name.
*/
void UnLoadPlugin(const std::string& pName);
/**
* A method, which registers particular plugin.
* @param pName A plugin name.
*/
void RegisterPlugin(const std::string& pName);
/**
* A method, which unregister particular plugin.
* @param pName A plugin name.
*/
void UnRegisterPlugin(const std::string& pName);
/**
* A method, which registers particular plugin,
* called via DBUS
* @param pName A plugin name.
* @param pDBUSSender DBUS user identification
*/
void RegisterPluginDBUS(const std::string& pName,
const char * pDBUSSender);
/**
* A method, which unregister particular plugin,
* called via DBUS
* @param pName A plugin name.
* @param pDBUSSender DBUS user identification
*/
void UnRegisterPluginDBUS(const std::string& pName,
const char * pDBUSSender);
/**
* A method, which returns instance of particular analyzer plugin.
* @param pName A plugin name.
* @return An analyzer plugin.
*/
CAnalyzer* GetAnalyzer(const std::string& pName);
/**
* A method, which returns instance of particular reporter plugin.
* @param pName A plugin name.
* @return A reporter plugin.
*/
CReporter* GetReporter(const std::string& pName);
/**
* A method, which returns instance of particular action plugin.
* @param pName A plugin name.
* @return An action plugin.
*/
CAction* GetAction(const std::string& pName);
/**
* A method, which returns instance of particular database plugin.
* @param pName A plugin name.
* @return A database plugin.
*/
CDatabase* GetDatabase(const std::string& pName);
/**
* A method, which returns type of particular plugin.
* @param pName A plugin name.
* @return A plugin type.
*/
plugin_type_t GetPluginType(const std::string& pName);
/**
* A method, which gets all plugins info (event those plugins which are
* disabled). It can be send via DBus to GUI and displayed to an user.
* Then a user can fill all needed informations like URLs etc.
* @return A vector of maps <key, vaule>
*/
vector_map_string_t GetPluginsInfo();
/**
* A method, which sets up a plugin. The settings are also saved in home
* directory of an user.
* @param pName A plugin name.
* @param pUID An uid of user.
* @param pSettings A plugin's settings.
*/
void SetPluginSettings(const std::string& pName,
const std::string& pUID,
const map_plugin_settings_t& pSettings);
/**
* A method, which returns plugin's settings according to user.
* @param pName A plugin name.
* @param pUID An uid of user.
* @return Plugin's settings accorting to user.
*/
map_plugin_settings_t GetPluginSettings(const std::string& pName,
const std::string& pUID);
};
/**
* Loads settings and stores it in second parameter. On success it
* returns true, otherwise returns false.
* @param path A path of config file.
* @param settings A readed plugin's settings.
* @return if it success it returns true, otherwise it returns false.
*/
bool LoadPluginSettings(const std::string& pPath,
map_plugin_settings_t& pSettings);
#endif /*PLUGINMANAGER_H_*/
|
