~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

#endif

 

#include "drizzled/internal/my_pthread.h"                       // For thr_setconcurency()

 

#include <drizzled/gettext.h>

 

 

#define IF_PURIFY(A,B) (A)

#else

#define IF_PURIFY(A,B) (B)

uint32_t dropping_tables, ha_open_options;

uint32_t tc_heuristic_recover= 0;

uint64_t session_startup_options;

uint32_t server_id;

uint64_t table_cache_size;

size_t table_def_size;

 

FILE *stderror_file=0;

 

struct global_counters current_global_counters;

 

const CHARSET_INFO *system_charset_info, *files_charset_info ;

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.completion_type= in_completion_type;

}

 

 

static void check_limits_dpi(uint32_t in_div_precincrement)

{

 

static void check_limits_map(uint32_t in_max_allowed_packet)

{

  if (in_max_allowed_packet < 1024 || in_max_allowed_packet > 1024*1024L*1024L)

  {

    cout << N_("Error: Invalid Value for max_allowed_packet");

  global_system_variables.transaction_message_threshold= in_transaction_message_threshold;

}

 

static void process_defaults_files()

{

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

       iter != defaults_file_list.end();

       ++iter)

  {

 

    ifstream input_defaults_file(file_location.file_string().c_str());

    

       it != in_options.end();

       ++it)

  {

  }

}

 

  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_("Run drizzled daemon as user."))  

  ("version,V", 

  N_("Output version information and exit."))

  N_("The number of outstanding connection requests Drizzle can have. This "

     "comes into play when the main Drizzle thread gets very many connection "

     "requests in a very short time."))

  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."))

  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_("If there is more than this number of interrupted connections from a "

  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(),

    {

      {

      }

    }

  }

 

  /* TODO: here is where we should add a process_env_vars */

 

  /* We need a notify here so that plugin_init will work properly */

  /* At this point, we've read all the options we need to read from files and

     collected most of them into unknown options - now let's load everything

  */

  {

    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);

    po::store(final_parsed, vm);

 

  }

  catch (po::invalid_command_line_syntax &err)

  {

    errmsg_printf(ERRMSG_LVL_ERROR,

    unireg_abort(1);

  }