← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/loader.cc

  • Committer: Olaf van der Spek
  • Date: 2011-07-05 13:16:34 UTC
  • mto: This revision was merged to the branch mainline in revision 2384.
  • Revision ID: olafvdspek@gmail.com-20110705131634-f7g1fjro5slibmdj
Add data_ref.h
Use str_ref for append_identifier

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/loader.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
 
#include "config.h"
 
16
#include <config.h>
17
17
 
18
18
#include <dlfcn.h>
19
19
 
26
26
 
27
27
#include <boost/program_options.hpp>
28
28
 
29
 
#include "drizzled/option.h"
30
 
#include "drizzled/internal/m_string.h"
 
29
#include <drizzled/option.h>
 
30
#include <drizzled/internal/m_string.h>
31
31
 
32
 
#include "drizzled/plugin.h"
33
 
#include "drizzled/module/load_list.h"
34
 
#include "drizzled/module/library.h"
35
 
#include "drizzled/module/registry.h"
36
 
#include "drizzled/module/option_context.h"
37
 
#include "drizzled/sql_parse.h"
38
 
#include "drizzled/show.h"
39
 
#include "drizzled/cursor.h"
40
 
#include "drizzled/set_var.h"
41
 
#include "drizzled/session.h"
42
 
#include "drizzled/item/null.h"
43
 
#include "drizzled/error.h"
44
 
#include "drizzled/gettext.h"
45
 
#include "drizzled/errmsg_print.h"
46
 
#include "drizzled/strfunc.h"
47
 
#include "drizzled/pthread_globals.h"
48
 
#include "drizzled/util/tokenize.h"
 
32
#include <drizzled/plugin.h>
 
33
#include <drizzled/module/load_list.h>
 
34
#include <drizzled/module/library.h>
 
35
#include <drizzled/module/registry.h>
 
36
#include <drizzled/module/option_context.h>
 
37
#include <drizzled/sql_parse.h>
 
38
#include <drizzled/show.h>
 
39
#include <drizzled/cursor.h>
 
40
#include <drizzled/set_var.h>
 
41
#include <drizzled/session.h>
 
42
#include <drizzled/item/null.h>
 
43
#include <drizzled/error.h>
 
44
#include <drizzled/gettext.h>
 
45
#include <drizzled/errmsg_print.h>
 
46
#include <drizzled/pthread_globals.h>
 
47
#include <drizzled/util/tokenize.h>
 
48
#include <drizzled/system_variables.h>
49
49
 
50
50
#include <boost/foreach.hpp>
51
51
 
71
71
  PANDORA_BUILTIN_LOAD_SYMBOLS_LIST, NULL
72
72
};
73
73
 
74
 
namespace drizzled
75
 
{
 
74
namespace drizzled {
76
75
 
77
76
 
78
77
typedef vector<string> PluginOptions;
108
107
  Item *item;
109
108
};
110
109
 
111
 
class Bookmark
112
 
{
113
 
public:
114
 
  Bookmark() :
115
 
    type_code(0),
116
 
    offset(0),
117
 
    version(0),
118
 
    key("")
119
 
  {}
120
 
  uint8_t type_code;
121
 
  int offset;
122
 
  uint32_t version;
123
 
  string key;
124
 
};
125
 
 
126
 
typedef boost::unordered_map<string, Bookmark> bookmark_unordered_map;
127
 
static bookmark_unordered_map bookmark_hash;
128
 
 
129
 
 
130
 
 
131
110
/* prototypes */
132
 
static void plugin_prune_list(vector<string> &plugin_list,
133
 
                              const vector<string> &plugins_to_remove);
 
111
static void plugin_prune_list(vector<string> &plugin_list, const vector<string> &plugins_to_remove);
134
112
static bool plugin_load_list(module::Registry &registry,
135
113
                             memory::Root *tmp_root,
136
114
                             const set<string> &plugin_list,
137
115
                             po::options_description &long_options,
138
116
                             bool builtin= false);
139
 
static int test_plugin_options(memory::Root *, module::Module *,
140
 
                               po::options_description &long_options);
 
117
static int test_plugin_options(memory::Root*, module::Module*, po::options_description&long_options);
141
118
static void unlock_variables(Session *session, drizzle_system_variables *vars);
142
119
static void cleanup_variables(drizzle_system_variables *vars);
143
120
 
167
144
    return false;
168
145
  }
169
146
 
170
 
  module::Module *tmp= NULL;
171
147
  /* Find plugin by name */
172
148
  const module::Manifest *manifest= library->getManifest();
173
149
 
181
157
    return true;
182
158
  }
183
159
 
184
 
  tmp= new (std::nothrow) module::Module(manifest, library);
185
 
  if (tmp == NULL)
186
 
    return true;
 
160
  module::Module* tmp= new module::Module(manifest, library);
187
161
 
188
162
  if (!test_plugin_options(tmp_root, tmp, long_options))
189
163
  {
198
172
 
199
173
static void reap_plugins(module::Registry &registry)
200
174
{
201
 
  std::map<std::string, module::Module *>::const_iterator modules=
202
 
    registry.getModulesMap().begin();
203
 
 
204
 
  while (modules != registry.getModulesMap().end())
205
 
  {
206
 
    module::Module *module= (*modules).second;
207
 
    delete module;
208
 
    ++modules;
209
 
  }
 
175
  BOOST_FOREACH(module::Registry::ModuleMap::const_reference module, registry.getModulesMap())
 
176
    delete module.second;
210
177
}
211
178
 
212
179
 
227
194
    }
228
195
  }
229
196
  module->isInited= true;
230
 
 
231
 
 
232
197
  return false;
233
198
}
234
199
 
235
 
 
236
 
inline static void dashes_to_underscores(std::string &name_in,
237
 
                                         char from= '-', char to= '_')
238
 
{
239
 
  for (string::iterator p= name_in.begin();
240
 
       p != name_in.end();
241
 
       ++p)
242
 
  {
243
 
    if (*p == from)
244
 
    {
245
 
      *p= to;
246
 
    }
247
 
  }
248
 
}
249
 
 
250
 
inline static void underscores_to_dashes(std::string &name_in)
251
 
{
252
 
  return dashes_to_underscores(name_in, '_', '-');
253
 
}
254
 
 
255
200
static void compose_plugin_options(vector<string> &target,
256
201
                                   vector<string> options)
257
202
{
258
 
  for (vector<string>::iterator it= options.begin();
259
 
       it != options.end();
260
 
       ++it)
261
 
  {
262
 
    tokenize(*it, target, ",", true);
263
 
  }
264
 
  for (vector<string>::iterator it= target.begin();
265
 
       it != target.end();
266
 
       ++it)
267
 
  {
268
 
    dashes_to_underscores(*it);
269
 
  }
 
203
  BOOST_FOREACH(vector<string>::reference it, options)
 
204
    tokenize(it, target, ",", true);
 
205
  BOOST_FOREACH(vector<string>::reference it, target)
 
206
    std::replace(it.begin(), it.end(), '-', '_');
270
207
}
271
208
 
272
209
void compose_plugin_add(vector<string> options)
294
231
bool plugin_init(module::Registry &registry,
295
232
                 po::options_description &long_options)
296
233
{
297
 
  memory::Root tmp_root(4096);
298
 
 
299
234
  if (initialized)
300
235
    return false;
301
236
 
302
 
  initialized= 1;
 
237
  initialized= true;
303
238
 
304
239
  PluginOptions builtin_load_list;
305
240
  tokenize(builtin_load_plugins, builtin_load_list, ",", true);
333
268
    plugin_prune_list(builtin_load_list, opt_plugin_remove);
334
269
  }
335
270
 
336
 
 
 
271
  memory::Root tmp_root(4096);
337
272
  /*
338
273
    First we register builtin plugins
339
274
  */
370
305
  /*
371
306
    Now we initialize all remaining plugins
372
307
  */
373
 
  module::Registry::ModuleList module_list= registry.getList();
374
 
  module::Registry::ModuleList::iterator modules= module_list.begin();
375
 
    
376
 
  while (modules != module_list.end())
 
308
  BOOST_FOREACH(module::Registry::ModuleList::const_reference module, registry.getList())
377
309
  {
378
 
    module::Module *module= *modules;
379
 
    ++modules;
380
 
    if (module->isInited == false)
 
310
    if (not module->isInited && plugin_initialize(registry, module))
381
311
    {
382
 
      if (plugin_initialize(registry, module))
383
 
      {
384
 
        registry.remove(module);
385
 
        delete module;
386
 
        return true;
387
 
      }
 
312
      registry.remove(module);
 
313
      delete module;
 
314
      return true;
388
315
    }
389
316
  }
390
 
 
391
 
 
392
317
  BOOST_FOREACH(plugin::Plugin::map::value_type value, registry.getPluginsMap())
393
318
  {
394
319
    value.second->prime();
395
320
  }
396
 
 
397
321
  return false;
398
322
}
399
323
 
448
372
                             po::options_description &long_options,
449
373
                             bool builtin)
450
374
{
451
 
  module::Library *library= NULL;
452
 
 
453
 
  for (set<string>::const_iterator iter= plugin_list.begin();
454
 
       iter != plugin_list.end();
455
 
       ++iter)
 
375
  BOOST_FOREACH(const string& plugin_name, plugin_list)
456
376
  {
457
 
    const string plugin_name(*iter);
458
 
 
459
 
    library= registry.addLibrary(plugin_name, builtin);
 
377
    module::Library* library= registry.addLibrary(plugin_name, builtin);
460
378
    if (library == NULL)
461
379
    {
462
380
      errmsg_printf(error::ERROR,
473
391
                    _("Couldn't load plugin named '%s'.\n"),
474
392
                    plugin_name.c_str());
475
393
      return true;
476
 
 
477
394
    }
478
395
  }
479
396
  return false;
480
397
}
481
398
 
482
 
 
483
399
void module_shutdown(module::Registry &registry)
484
400
{
485
 
 
486
401
  if (initialized)
487
402
  {
488
403
    reap_needed= true;