← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/drizzled.cc

  • Committer: lbieber
  • Date: 2010-09-22 03:57:16 UTC
  • mfrom: (1783.1.3 build)
  • Revision ID: lbieber@orisndriz08-20100922035716-9r10weyqvpxfn633
Merge Monty - fix processing of configuration files
Merge Brian - Pushes up thread ownership to the modules that create them.
Merge Monty - fix bug 643814 - add links for drizzle7 changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/drizzled.cc
61
61
#include "plugin/myisam/myisam.h"
62
62
#include "drizzled/drizzled.h"
63
63
#include "drizzled/module/registry.h"
 
64
#include "drizzled/module/load_list.h"
64
65
 
65
66
#include <google/protobuf/stubs/common.h>
66
67
 
176
177
 
177
178
const char *first_keyword= "first";
178
179
const char * const DRIZZLE_CONFIG_NAME= "drizzled";
 
180
 
179
181
#define GET_HA_ROWS GET_ULL
180
182
 
181
183
const char *tx_isolation_names[] =
361
363
po::options_description long_options("Kernel Options");
362
364
po::options_description plugin_options("Plugin Options");
363
365
vector<string> unknown_options;
 
366
vector<string> defaults_file_list;
364
367
po::variables_map vm;
365
368
 
366
369
po::variables_map &getVariablesMap()
629
632
 
630
633
  delete session;
631
634
  LOCK_thread_count.unlock();
632
 
 
633
 
  return;
634
635
}
635
636
 
636
637
 
1036
1037
  return make_pair(string(""), string(""));
1037
1038
}
1038
1039
 
 
1040
static void process_defaults_files()
 
1041
{
 
1042
  for (vector<string>::iterator iter= defaults_file_list.begin();
 
1043
       iter != defaults_file_list.end();
 
1044
       ++iter)
 
1045
  {
 
1046
    string file_location(vm["config-dir"].as<string>());
 
1047
    if ((*iter)[0] != '/')
 
1048
    {
 
1049
      /* Relative path - add config dir */
 
1050
      file_location.push_back('/');
 
1051
      file_location.append(*iter);
 
1052
    }
 
1053
    else
 
1054
    {
 
1055
      file_location= *iter;
 
1056
    }
 
1057
 
 
1058
    ifstream input_defaults_file(file_location.c_str());
 
1059
    
 
1060
    po::parsed_options file_parsed=
 
1061
      po::parse_config_file(input_defaults_file, long_options, true);
 
1062
    vector<string> file_unknown= 
 
1063
      po::collect_unrecognized(file_parsed.options, po::include_positional);
 
1064
 
 
1065
    for (vector<string>::iterator it= file_unknown.begin();
 
1066
         it != file_unknown.end();
 
1067
         ++it)
 
1068
    {
 
1069
      string new_unknown_opt("--");
 
1070
      new_unknown_opt.append(*it);
 
1071
      ++it;
 
1072
      if (it != file_unknown.end())
 
1073
      {
 
1074
        if ((*it) != "true")
 
1075
        {
 
1076
          new_unknown_opt.push_back('=');
 
1077
          new_unknown_opt.append(*it);
 
1078
        }
 
1079
      }
 
1080
      else
 
1081
      {
 
1082
        break;
 
1083
      }
 
1084
      unknown_options.push_back(new_unknown_opt);
 
1085
    }
 
1086
    store(file_parsed, vm);
 
1087
  }
 
1088
}
 
1089
 
 
1090
static void compose_defaults_file_list(vector<string> in_options)
 
1091
{
 
1092
  for (vector<string>::iterator it= in_options.begin();
 
1093
       it != in_options.end();
 
1094
       ++it)
 
1095
  {
 
1096
    defaults_file_list.push_back(*it);
 
1097
  }
 
1098
}
1039
1099
 
1040
1100
int init_common_variables(int argc, char **argv)
1041
1101
{
1079
1139
    strncpy(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
1080
1140
  strcpy(internal::fn_ext(pidfile_name),".pid");                // Add proper extension
1081
1141
 
1082
 
 
1083
 
 
1084
 
 
1085
1142
  std::string system_config_dir_drizzle(SYSCONFDIR);
1086
 
  system_config_dir_drizzle.append("/drizzle/drizzle.cnf");
 
1143
  system_config_dir_drizzle.append("/drizzle");
 
1144
 
 
1145
  std::string system_config_file_drizzle("drizzled.cnf");
1087
1146
 
1088
1147
  long_options.add_options()
1089
1148
  ("help-extended", po::value<bool>(&opt_help_extended)->default_value(false)->zero_tokens(),
1200
1259
     "testing/comparison)."))
1201
1260
  ("plugin-dir", po::value<string>(),
1202
1261
  N_("Directory for plugins."))
1203
 
  ("plugin-add", po::value<string>(),
 
1262
  ("plugin-add", po::value<vector<string> >()->composing()->notifier(&compose_plugin_add),
1204
1263
  N_("Optional comma separated list of plugins to load at startup in addition "
1205
1264
     "to the default list of plugins. "
1206
1265
     "[for example: --plugin_add=crc32,logger_gearman]"))    
1207
 
  ("plugin-remove", po::value<string>(),
 
1266
  ("plugin-remove", po::value<vector<string> >()->composing()->notifier(&compose_plugin_remove),
1208
1267
  N_("Optional comma separated list of plugins to not load at startup. Effectively "
1209
1268
     "removes a plugin from the list of plugins to be loaded. "
1210
1269
     "[for example: --plugin_remove=crc32,logger_gearman]"))
1211
 
  ("plugin-load", po::value<string>(),
 
1270
  ("plugin-load", po::value<string>()->notifier(&notify_plugin_load)->default_value(PANDORA_PLUGIN_LIST),
1212
1271
  N_("Optional comma separated list of plugins to load at starup instead of "
1213
1272
     "the default plugin load list. "
1214
1273
     "[for example: --plugin_load=crc32,logger_gearman]"))  
1253
1312
     " automatically convert it to an on-disk MyISAM table."))
1254
1313
  ("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),
1255
1314
  N_("Configuration file defaults are not used if no-defaults is set"))
1256
 
  ("defaults-file", po::value<string>()->default_value(system_config_dir_drizzle),
 
1315
  ("defaults-file", po::value<vector<string> >()->composing()->notifier(&compose_defaults_file_list),
1257
1316
   N_("Configuration file to use"))
 
1317
  ("config-dir", po::value<string>()->default_value(system_config_dir_drizzle),
 
1318
   N_("Base location for config files"))
1258
1319
  ;
1259
1320
 
1260
1321
  po::parsed_options parsed= po::command_line_parser(argc, argv).
1272
1333
    unireg_abort(1);
1273
1334
  }
1274
1335
 
1275
 
 
1276
 
  if (! vm["no-defaults"].as<bool>())
1277
 
  {
1278
 
    ifstream system_drizzle_ifs(vm["defaults-file"].as<string>().c_str());
1279
 
    store(po::parse_config_file(system_drizzle_ifs, long_options), vm);
1280
 
  }
1281
 
 
 
1336
  if (not vm["no-defaults"].as<bool>())
 
1337
  {
 
1338
    defaults_file_list.insert(defaults_file_list.begin(),
 
1339
                              system_config_file_drizzle);
 
1340
  }
 
1341
 
 
1342
  string config_conf_d_location(vm["config-dir"].as<string>());
 
1343
  config_conf_d_location.append("/conf.d");
 
1344
  CachedDirectory config_conf_d(config_conf_d_location);
 
1345
  if (not config_conf_d.fail())
 
1346
  {
 
1347
 
 
1348
    for (CachedDirectory::Entries::const_iterator iter= config_conf_d.getEntries().begin();
 
1349
         iter != config_conf_d.getEntries().end();
 
1350
         ++iter)
 
1351
    {
 
1352
      string file_entry((*iter)->filename);
 
1353
          
 
1354
      if (not file_entry.empty()
 
1355
          && file_entry != "."
 
1356
          && file_entry != "..")
 
1357
      {
 
1358
        string the_entry(config_conf_d_location);
 
1359
        the_entry.push_back('/');
 
1360
        the_entry.append(file_entry);
 
1361
        defaults_file_list.push_back(the_entry);
 
1362
      }
 
1363
    }
 
1364
  }
 
1365
 
 
1366
  po::notify(vm);
 
1367
  process_defaults_files();
1282
1368
  po::notify(vm);
1283
1369
 
1284
1370
  get_options();
1395
1481
  if (opt_help || opt_help_extended)
1396
1482
    unireg_abort(0);
1397
1483
 
1398
 
  po::parsed_options parsed= po::command_line_parser(unknown_options).
1399
 
    options(plugin_options).extra_parser(parse_size_arg).
1400
 
    allow_unregistered().run();
1401
 
 
1402
 
  vector<string> final_unknown_options=
1403
 
    po::collect_unrecognized(parsed.options, po::include_positional);
1404
 
 
1405
 
  /* we do want to exit if there are any other unknown options */
1406
 
  /** @TODO: We should perhaps remove allowed_unregistered() and catch the
1407
 
    exception here */
1408
 
  if (final_unknown_options.size() > 0)
1409
 
  {
1410
 
     errmsg_printf(ERRMSG_LVL_ERROR,
1411
 
            _("%s: Unknown options given (first unknown is '%s').\n"
1412
 
              "Use --help to get a list of available options\n"),
1413
 
            internal::my_progname, final_unknown_options[0].c_str());
1414
 
      unireg_abort(1);
1415
 
  }
1416
 
 
 
1484
  vector<string> final_unknown_options;
1417
1485
  try
1418
1486
  {
 
1487
    po::parsed_options parsed=
 
1488
      po::command_line_parser(unknown_options).
 
1489
      options(plugin_options).extra_parser(parse_size_arg).run();
 
1490
 
 
1491
    final_unknown_options=
 
1492
      po::collect_unrecognized(parsed.options, po::include_positional);
 
1493
 
1419
1494
    po::store(parsed, vm);
1420
 
  }
1421
 
  catch (...)
1422
 
  {
1423
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Duplicate entry for command line option\n"));
1424
 
    unireg_abort(1);
1425
 
  }
1426
1495
 
1427
 
  if (not vm["no-defaults"].as<bool>())
1428
 
  {
1429
 
    ifstream system_drizzle_ifs(vm["defaults-file"].as<string>().c_str());
1430
 
    store(po::parse_config_file(system_drizzle_ifs, long_options), vm);
 
1496
  }
 
1497
  catch (po::invalid_command_line_syntax &err)
 
1498
  {
 
1499
    errmsg_printf(ERRMSG_LVL_ERROR,
 
1500
                  _("%s: %s.\n"
 
1501
                    "Use --help to get a list of available options\n"),
 
1502
                  internal::my_progname, err.what());
 
1503
    unireg_abort(1);
 
1504
  }
 
1505
  catch (po::unknown_option &err)
 
1506
  {
 
1507
    errmsg_printf(ERRMSG_LVL_ERROR,
 
1508
                  _("%s\nUse --help to get a list of available options\n"),
 
1509
                  err.what());
 
1510
    unireg_abort(1);
1431
1511
  }
1432
1512
 
1433
1513
  po::notify(vm);
1804
1884
   N_("Optional comma separated list of plugins to load at startup in addition "
1805
1885
      "to the default list of plugins. "
1806
1886
      "[for example: --plugin_add=crc32,logger_gearman]"),
1807
 
   (char**) &opt_plugin_add, (char**) &opt_plugin_add, 0,
 
1887
   NULL, NULL, 0,
1808
1888
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1809
1889
  {"plugin_remove", OPT_PLUGIN_ADD,
1810
1890
   N_("Optional comma separated list of plugins to not load at startup. Effectively "
1811
1891
      "removes a plugin from the list of plugins to be loaded. "
1812
1892
      "[for example: --plugin_remove=crc32,logger_gearman]"),
1813
 
   (char**) &opt_plugin_remove, (char**) &opt_plugin_remove, 0,
 
1893
   NULL, NULL, 0,
1814
1894
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1815
1895
  {"plugin_load", OPT_PLUGIN_LOAD,
1816
1896
   N_("Optional comma separated list of plugins to load at starup instead of "
1817
1897
      "the default plugin load list. "
1818
1898
      "[for example: --plugin_load=crc32,logger_gearman]"),
1819
 
   (char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,
 
1899
   NULL, NULL, 0,
1820
1900
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1821
1901
  {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
1822
1902
   N_("The size of the buffer that is allocated when preloading indexes"),
2131
2211
  }
2132
2212
 
2133
2213
  /* @TODO Make this all strings */
2134
 
  if (vm.count("plugin-remove"))
2135
 
  {
2136
 
    opt_plugin_remove= (char *)vm["plugin-remove"].as<string>().c_str();
2137
 
  }
2138
 
  if (vm.count("plugin-add"))
2139
 
  {
2140
 
    opt_plugin_add= (char *)vm["plugin-add"].as<string>().c_str();
2141
 
  }
2142
 
  if (vm.count("plugin-load"))
2143
 
  {
2144
 
    opt_plugin_load= (char *)vm["plugin-load"].as<string>().c_str();
2145
 
  }
2146
2214
  if (vm.count("default-storage-engine"))
2147
2215
  {
2148
2216
    default_storage_engine_str= (char *)vm["default-storage-engine"].as<string>().c_str();