~drizzle-trunk/drizzle/development

#include "drizzled/plugin/monitored_in_transaction.h"

#include "drizzled/replication_services.h" /* For ReplicationServices::evaluateRegisteredPlugins() */

#include "drizzled/probes.h"

#include "drizzled/charset.h"

#include "plugin/myisam/myisam.h"

#include "drizzled/drizzled.h"

#include "drizzled/module/registry.h"

#include "drizzled/module/load_list.h"

 

#include "drizzled/plugin/event_observer.h"

 

#include <google/protobuf/stubs/common.h>

 

#if TIME_WITH_SYS_TIME

SHOW_COMP_OPTION have_symlink;

 

/* Thread specific variables */

boost::mutex LOCK_global_system_variables;

 

boost::condition_variable_any COND_refresh;

boost::condition_variable COND_thread_count;

 

atomic<uint32_t> connection_count;

 

/** 

  Refresh value. We use to test this to find out if a refresh even has happened recently.

*/

 

  /* kill connection thread */

  {

 

    while (select_thread_in_use)

    {

    statements and inform their clients that the server is about to die.

  */

 

  {

    {

      DRIZZLE_CONNECTION_DONE(tmp->thread_id);

      tmp->lockOnSys();

    }

  }

 

    sleep(2);                                   // Give threads time to die

 

  /*

  */

  for (;;)

  {

    {

      break;

    }

    /* Close before unlock, avoiding crash. See LP bug#436685 */

  }

}

 

 

  if (print_message && server_start_time)

    errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_SHUTDOWN_COMPLETE)),internal::my_progname);

 

  /*

    The following lines may never be executed as the main thread may have

    }

    return NULL;

  }

  {

      errmsg_printf(ERRMSG_LVL_ERROR, _("Fatal error: Please read \"Security\" section of "

                      "the manual to find out how to run drizzled as root!\n"));

  SYNOPSIS

    Session::unlink()

    session              Thread handler

*/

 

{

  connection_count.decrement();

 

  session->cleanup();

 

 

  if (unlikely(plugin::EventObserver::disconnectSession(*session)))

  {

    // We should do something about an error...

  }

}

 

 

  global_system_variables.transaction_message_threshold= in_transaction_message_threshold;

}

 

static void process_defaults_files()

{

  for (vector<string>::iterator iter= defaults_file_list.begin();

  pid_file.replace_extension(".pid");

 

  system_config_dir /= "drizzle";

 

  config_options.add_options()

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

  N_("Pid file used by drizzled."))

  ("port-open-timeout", po::value<uint32_t>(&drizzled_bind_timeout)->default_value(0),

  N_("Maximum time in seconds to wait for the port to become free. "))

  ("secure-file-priv", po::value<fs::path>(&secure_file_priv)->notifier(expand_secure_file_priv),

  N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "

     "within specified directory"))

  N_("The maximum length of the result of function  group_concat."))

  ("join-buffer-size", po::value<uint64_t>(&global_system_variables.join_buff_size)->default_value(128*1024L)->notifier(&check_limits_join_buffer_size),

  N_("The size of the buffer that is used for full joins."))

  ("max-allowed-packet", po::value<uint32_t>(&global_system_variables.max_allowed_packet)->default_value(64*1024*1024L)->notifier(&check_limits_map),

  N_("Max packetlength to send/receive from to server."))

  ("max-connect-errors", po::value<uint64_t>(&max_connect_errors)->default_value(MAX_CONNECT_ERRORS)->notifier(&check_limits_mce),

  N_("Each thread that does a sequential scan allocates a buffer of this "

      "size for each table it scans. If you do many sequential scans, you may "

      "want to increase this value."))

  ("read-rnd-buffer-size",

  po::value<uint32_t>(&global_system_variables.read_rnd_buff_size)->default_value(256*1024L)->notifier(&check_limits_read_rnd_buffer_size),

  N_("When reading rows in sorted order after a sort, the rows are read "

     "through this buffer to avoid a disk seeks. If not set, then it's set "

     "to the value of record_buffer."))

  ("scheduler", po::value<string>(),

  N_("Select scheduler to be used (by default multi-thread)."))

  ("sort-buffer-size",

  po::value<size_t>(&global_system_variables.sortbuff_size)->default_value(MAX_SORT_MEMORY)->notifier(&check_limits_sort_buffer_size),

  N_("Each thread that needs to do a sort allocates a buffer of this size."))

  ("table-definition-cache", po::value<size_t>(&table_def_size)->default_value(128)->notifier(&check_limits_tdc),

  N_("The number of cached table definitions."))

  ("table-open-cache", po::value<uint64_t>(&table_cache_size)->default_value(TABLE_OPEN_CACHE_DEFAULT)->notifier(&check_limits_toc),

  {

    po::store(parsed, vm);

  }

  {

    errmsg_printf(ERRMSG_LVL_ERROR, _("Duplicate entry for command line option\n"));

    unireg_abort(1);

 

  if (not vm["no-defaults"].as<bool>())

  {

    defaults_file_list.insert(defaults_file_list.begin(),

 

    fs::path config_conf_d_location(system_config_dir);

    config_conf_d_location /= "conf.d";

 

    CachedDirectory config_conf_d(config_conf_d_location.file_string());

    if (not config_conf_d.fail())

    {

  {

    po::parsed_options final_parsed=

      po::command_line_parser(unknown_options).style(style).

 

    final_unknown_options=

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

  }

 

  // Resize the definition Cache at startup

  definition::Cache::singleton().rehash(table_def_size);

 

  setup_fpu();

 

  session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

  refresh_version= 1L;  /* Increments on each reload */

  global_thread_id= 1UL;

 

  /* Variables in libraries */

  default_character_set_name= "utf8";

    exit(0);

  }

 

  if (vm.count("exit-info"))

  {

    if (vm["exit-info"].as<long>())

    pid_file_path= getDataHome();

    pid_file_path /= pid_file;

  }

 

  if (not opt_help)

  {