~drizzle-trunk/drizzle/development

#include <boost/thread/recursive_mutex.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/condition_variable.hpp>

 

#include "drizzled/internal/my_sys.h"

#include "drizzled/internal/my_bit.h"

 

 

using namespace std;

namespace po=boost::program_options;

 

 

bool volatile abort_loop;

bool volatile shutdown_in_progress;

char *opt_scheduler_default;

 

size_t my_thread_stack_size= 0;

 

static void drizzle_init_variables(void);

static void get_options();

static const char *get_relative_path(const char *path);

 

static void usage(void);

void close_connections(void);

 

po::options_description long_options("Kernel Options");

po::options_description plugin_options("Plugin Options");

vector<string> unknown_options;

vector<string> defaults_file_list;

po::variables_map vm;

  DRIZZLE_CONFIG_NAME, "server", 0, 0

};

 

static void check_limits_aii(uint64_t in_auto_increment_increment)

{

  global_system_variables.auto_increment_increment= 1;

    ifstream input_defaults_file(file_location.c_str());

    

    po::parsed_options file_parsed=

    vector<string> file_unknown= 

      po::collect_unrecognized(file_parsed.options, po::include_positional);

 

  }

}

 

{

  time_t curr_time;

  umask(((~internal::my_umask) & 0666));

 

  drizzle_init_variables();

 

  {

    struct tm tm_tmp;

    localtime_r(&server_start_time,&tm_tmp);

 

  std::string system_config_file_drizzle("drizzled.cnf");

 

  ("help-extended", po::value<bool>(&opt_help_extended)->default_value(false)->zero_tokens(),

  N_("Display this help and exit after initializing plugins."))

  ("help,?", po::value<bool>(&opt_help)->default_value(false)->zero_tokens(),

  N_("Display this help and exit."))

  ("auto-increment-increment", po::value<uint64_t>(&global_system_variables.auto_increment_increment)->default_value(1)->notifier(&check_limits_aii),

  N_("Auto-increment columns are incremented by this"))

  ("auto-increment-offset", po::value<uint64_t>(&global_system_variables.auto_increment_offset)->default_value(1)->notifier(&check_limits_aio),

     "automatically pick a reasonable value; if set to MAX_TABLES+2, the "

     "optimizer will switch to the original find_best (used for "

     "testing/comparison)."))

  ("preload-buffer-size", po::value<uint64_t>(&global_system_variables.preload_buff_size)->default_value(32*1024L)->notifier(&check_limits_pbs),

  N_("The size of the buffer that is allocated when preloading indexes"))

  ("query-alloc-block-size", 

  po::value<uint64_t>(&global_system_variables.tmp_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_tmp_table_size),

  N_("If an internal in-memory temporary table exceeds this size, Drizzle will"

     " automatically convert it to an on-disk MyISAM table."))

  ;

 

  int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

  po::parsed_options parsed= po::command_line_parser(argc, argv).style(style).

  unknown_options=

    po::collect_unrecognized(parsed.options, po::include_positional);

 

    }

  }

 

  process_defaults_files();

  po::notify(vm);

 

  get_options();

    }

  }

 

 

  current_pid= getpid();                /* Save for later ref */

  init_time();                          /* Init time-functions (read zone) */

    return 1;                           // Eof of the list

  }

 

  if (default_collation_name)

  {

    const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

  /* Allow storage engine to give real error messages */

  ha_init_errors();

 

 

  if (opt_help || opt_help_extended)

    unireg_abort(0);

 

 

  string scheduler_name;

  if (opt_scheduler)

   0, GET_UINT, OPT_ARG, 0, 0, MAX_TABLES+2, 0, 1, 0},

  {"plugin_dir", OPT_PLUGIN_DIR,

   N_("Directory for plugins."),

   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"plugin_add", OPT_PLUGIN_ADD,

   N_("Optional comma separated list of plugins to load at startup in addition "

  printf(_("Usage: %s [OPTIONS]\n"), internal::my_progname);

 

  po::options_description all_options("Drizzled Options");

  all_options.add(long_options);

  all_options.add(plugin_options);

  cout << all_options << endl;

}

 

 

{

  char buff[FN_REFLEN],*pos,rp_buff[PATH_MAX];

  internal::convert_dirname(drizzle_home,drizzle_home,NULL);

  }

  internal::convert_dirname(language,language,NULL);

  (void) internal::my_load_path(drizzle_home, drizzle_home,""); // Resolve current dir

 

  const char *sharedir= get_relative_path(PKGDATADIR);

  if (internal::test_if_hard_path(sharedir))

      drizzle_tmpdir.append(tmp_string);

    }

 

    assert(drizzle_tmpdir.size());

 

    if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)