Merge lp:~mordred/drizzle/bug675670 into lp:drizzle/7.0

[Monty Taylor]

Modifies Brian's branch a bit to add an option for clobbering existing socket files which is off by default.

[lp:~mordred/drizzle/bug675670]

1940. By Brian Aker on 2010-11-19

Rollup merge for barrier patch

1941. By Brian Aker on 2010-11-19

Merge in Monty

1942. By Lee Bieber on 2010-11-20

Merge Billy - removed my_getsysdate, my_micro_time and my_micro_time_and_time and replaced with boost::date_time for compatibility.

[Lee Bieber (kalebral-deactivatedaccount)]

distcheck targets are failing

review: Needs Fixing

[Lee Bieber (kalebral-deactivatedaccount)]

Tests don't run on these platforms when running distcheck
http://hudson.drizzle.org/view/Drizzle-build/job/drizzle-build-ubuntu10.04-32bit/
http://hudson.drizzle.org/view/Drizzle-build/job/drizzle-build-ubuntu10.10-32bit/
http://hudson.drizzle.org/view/Drizzle-build/job/drizzle-build-ubuntu10.10-64bit/

[lp:~mordred/drizzle/bug675670]

1943. By Lee Bieber on 2010-11-20

Merge Lee - Run bzr ignore for leftover files
Merge Shrews - Add a --replicate-query option to the server which controls whether or not the SQL query string is included in the GPB Statement messages.
Merge Andrew - fix bug 665119: drizzleslap has -i mapped to two options
Merge Andrew fix bug 674145: Table Names Not Case Matched

1944. By Lee Bieber on 2010-11-20

Merge Brian - refactor share

1945. By Brian Aker on 2010-11-21

Merge in simple change such that we use the KEY we already have, instead of
recalculating one.

[Monty Taylor (mordred)]

This is all working for me in param-build.

[lp:~mordred/drizzle/bug675670]

1953. By Monty Taylor on 2010-11-23

We were overrunning the buffer everywhere, but glibc on ubuntu was
notificing for us.

=== modified file 'drizzled/constrained_value.h'
--- drizzled/constrained_value.h	2010-11-09 21:48:09 +0000
+++ drizzled/constrained_value.h	2010-11-23 02:58:45 +0000
@@ -93,6 +93,57 @@
   }
 };
 
+namespace
+{
+template<class T, T min_val>
+bool less_than_min(T val_to_check)
+{
+  return val_to_check < min_val;
+}
+
+template<>
+inline bool less_than_min<uint16_t, 0>(uint16_t)
+{
+  return false;
+}
+
+template<>
+inline bool less_than_min<uint32_t, 0>(uint32_t)
+{
+  return false;
+}
+
+template<>
+inline bool less_than_min<uint64_t, 0>(uint64_t)
+{
+  return false;
+}
+
+template<class T, T min_val>
+bool greater_than_max(T val_to_check)
+{
+  return val_to_check > min_val;
+}
+
+template<>
+inline bool greater_than_max<uint16_t, UINT16_MAX>(uint16_t)
+{
+  return false;
+}
+
+template<>
+inline bool greater_than_max<uint32_t, UINT32_MAX>(uint32_t)
+{
+  return false;
+}
+
+template<>
+inline bool greater_than_max<uint64_t, UINT64_MAX>(uint64_t)
+{
+  return false;
+}
+} 
+
 template<class T,
   T MAXVAL,
   T MINVAL, unsigned int ALIGN= 1>
@@ -112,7 +163,7 @@
 
   constrained_value<T>& set_value(T rhs)
   {
-    if ((rhs > MAXVAL) || (rhs < MINVAL))
+    if (greater_than_max<T,MAXVAL>(rhs) || less_than_min<T,MINVAL>(rhs))
     {
       boost::throw_exception(boost::program_options::invalid_option_value(boost::lexical_cast<std::string>(rhs)));
     }

=== modified file 'drizzled/sys_var.cc'
--- drizzled/sys_var.cc	2010-11-19 15:23:07 +0000
+++ drizzled/sys_var.cc	2010-11-23 02:58:45 +0000
@@ -338,6 +338,22 @@
   return res;
 }
 
+bool sys_var_std_string::check(Session *session, set_var *var)
+{
+  if (check_func == NULL)
+  {
+    return false;
+  }
+
+  int res= (*check_func)(session, var);
+  if (res != 0)
+  {
+    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), getName().c_str(), var->value->str_value.ptr());
+    return true;
+  }
+  return false;
+}
+
 /*
   Functions to check and update variables
 */

=== modified file 'drizzled/sys_var.h'
--- drizzled/sys_var.h	2010-11-09 21:50:25 +0000
+++ drizzled/sys_var.h	2010-11-23 02:58:45 +0000
@@ -519,6 +519,63 @@
   }
 };
 
+class sys_var_std_string :
+  public sys_var
+{
+  std::string &value;
+  sys_check_func check_func;
+  sys_update_func update_func;
+  sys_set_default_func set_default_func;
+public:
+  sys_var_std_string(const std::string &name_arg,
+                     std::string &value_arg,
+                     sys_check_func check_func_arg= NULL,
+                     sys_update_func update_func_arg= NULL) :
+    sys_var(name_arg),
+    value(value_arg),
+    check_func(check_func_arg),
+    update_func(update_func_arg)
+  {  }
+
+  inline void set(char *val_in)
+  {
+    value= val_in; 
+  }
+
+  void set_check_func(sys_check_func check_func_arg= NULL)
+  {
+    check_func= check_func_arg;
+  }
+
+  void set_update_func(sys_update_func update_func_arg= NULL)
+  {
+    update_func= update_func_arg;
+  }
+
+  bool check(Session *session, set_var *var);
+    
+  bool update(Session *session, set_var *var)
+  {
+    if (update_func != NULL)
+    {
+      return (*update_func)(session, var);
+    }
+    return false;
+  }
+  SHOW_TYPE show_type() { return SHOW_CHAR; }
+  unsigned char *value_ptr(Session *, sql_var_t, const LEX_STRING *)
+  {
+    return (unsigned char*)(value.c_str());
+  }
+  bool check_update_type(Item_result type)
+  {
+    return type != STRING_RESULT;		/* Only accept strings */
+  }
+  bool check_default(sql_var_t)
+  { return true; }
+  bool is_readonly() const { return false; }
+};
+
 class sys_var_const_string :
   public sys_var
 {

=== modified file 'plugin/auth_http/auth_http.cc'
--- plugin/auth_http/auth_http.cc	2010-07-16 09:26:33 +0000
+++ plugin/auth_http/auth_http.cc	2010-11-23 02:58:45 +0000
@@ -32,9 +32,6 @@
 using namespace drizzled;
 using namespace std;
 
-static bool sysvar_auth_http_enable;
-static char* sysvar_auth_http_url= NULL;
-
 static size_t curl_cb_read(void *ptr, size_t size, size_t nmemb, void *stream)
 {
   (void) ptr;
@@ -47,9 +44,11 @@
 {
   CURLcode rv;
   CURL *curl_handle;
+  const std::string auth_url;
 public:
-  Auth_http(std::string name_arg)
-    : drizzled::plugin::Authentication(name_arg)
+  Auth_http(std::string name_arg, const std::string &url_arg) :
+    drizzled::plugin::Authentication(name_arg),
+    auth_url(url_arg)
   {
     // we are trusting that plugin initializers are called singlethreaded at startup
     // if something else also calls curl_global_init() in a threadrace while we are here,
@@ -78,14 +77,10 @@
   {
     long http_response_code;
 
-    if (sysvar_auth_http_enable == false)
-      return true;
-
     assert(sctx.getUser().c_str());
 
-
     // set the parameters: url, username, password
-    rv= curl_easy_setopt(curl_handle, CURLOPT_URL, sysvar_auth_http_url);
+    rv= curl_easy_setopt(curl_handle, CURLOPT_URL, auth_url.c_str());
 #if defined(HAVE_CURLOPT_USERNAME)
 
     rv= curl_easy_setopt(curl_handle, CURLOPT_USERNAME,
@@ -123,6 +118,8 @@
 
 static int initialize(drizzled::module::Context &context)
 {
+  const module::option_map &vm= context.getOptions();
+
   /* 
    * Per libcurl manual, in multi-threaded applications, curl_global_init() should
    * be called *before* curl_easy_init()...which is called in Auto_http's 
@@ -131,43 +128,29 @@
   if (curl_global_init(CURL_GLOBAL_NOTHING) != 0)
     return 1;
 
-  auth= new Auth_http("auth_http");
+  const string auth_url(vm["url"].as<string>());
+  if (auth_url.size() == 0)
+  {
+    errmsg_printf(ERRMSG_LVL_ERROR,
+                  _("auth_http plugin loaded but required option url not "
+                    "specified. Against which URL are you intending on "
+                    "authenticating?\n"));
+    return 1;
+  }
+
+  auth= new Auth_http("auth_http", auth_url);
   context.add(auth);
+  context.registerVariable(new sys_var_const_string_val("url", auth_url));
 
   return 0;
 }
 
 static void init_options(drizzled::module::option_context &context)
 {
-   context("enable", po::value<bool>(&sysvar_auth_http_enable)->default_value(false)->zero_tokens(),
-           N_("Enable HTTP Auth check"));
+  context("url", po::value<string>()->default_value(""),
+          N_("URL for HTTP Auth check"));
 } 
 
-static DRIZZLE_SYSVAR_BOOL(
-  enable,
-  sysvar_auth_http_enable,
-  PLUGIN_VAR_NOCMDARG,
-  N_("Enable HTTP Auth check"),
-  NULL, /* check func */
-  NULL, /* update func */
-  false /* default */);
-
-
-static DRIZZLE_SYSVAR_STR(
-  url,
-  sysvar_auth_http_url,
-  PLUGIN_VAR_READONLY,
-  N_("URL for HTTP Auth check"),
-  NULL, /* check func */
-  NULL, /* update func*/
-  "http://localhost/" /* default */);
-
-static drizzle_sys_var* auth_http_system_variables[]= {
-  DRIZZLE_SYSVAR(enable),
-  DRIZZLE_SYSVAR(url),
-  NULL
-};
-
 
 DRIZZLE_DECLARE_PLUGIN
 {
@@ -178,7 +161,7 @@
   "HTTP based authenication.",
   PLUGIN_LICENSE_GPL,
   initialize, /* Plugin Init */
-  auth_http_system_variables,
+  NULL,
   init_options    /* config options */
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/haildb/haildb_engine.cc'
--- plugin/haildb/haildb_engine.cc	2010-11-12 01:10:48 +0000
+++ plugin/haildb/haildb_engine.cc	2010-11-23 02:58:45 +0000
@@ -2818,9 +2818,7 @@
   return err;
 }
 
-static char*  innobase_log_group_home_dir   = NULL;
 static bool innobase_use_doublewrite= true;
-static unsigned long innobase_fast_shutdown= 1;
 static bool srv_file_per_table= false;
 static bool innobase_adaptive_hash_index;
 static bool srv_adaptive_flushing;
@@ -2828,9 +2826,7 @@
 static bool innobase_rollback_on_timeout;
 static bool innobase_create_status_file;
 static bool srv_use_sys_malloc;
-static char*  innobase_file_format_name   = const_cast<char *>("Barracuda");
-static char*  innobase_unix_file_flush_method   = NULL;
-static unsigned long srv_flush_log_at_trx_commit;
+static string innobase_file_format_name;
 static unsigned long srv_max_buf_pool_modified_pct;
 static unsigned long srv_max_purge_lag;
 static unsigned long innobase_lru_old_blocks_pct;
@@ -2847,10 +2843,14 @@
 static additional_mem_pool_constraint innobase_additional_mem_pool_size;
 static bool  innobase_use_checksums= true;
 typedef constrained_check<unsigned int, UINT_MAX, 100> io_capacity_constraint;
+typedef constrained_check<uint16_t, 2, 0> trinary_constraint;
+static trinary_constraint innobase_fast_shutdown;
+static trinary_constraint srv_flush_log_at_trx_commit;
+typedef constrained_check<uint16_t, 6, 0> force_recovery_constraint;
+static force_recovery_constraint innobase_force_recovery;
 static io_capacity_constraint srv_io_capacity;
 
 static long innobase_open_files;
-static long innobase_force_recovery;
 static long innobase_log_buffer_size;
 static char  default_haildb_data_file_path[]= "ibdata1:10M:autoextend";
 static char* haildb_data_file_path= NULL;
@@ -2858,6 +2858,24 @@
 static int64_t haildb_log_file_size;
 static int64_t haildb_log_files_in_group;
 
+static int haildb_file_format_name_validate(Session*, set_var *var)
+{
+
+  const char *format= var->value->str_value.ptr();
+  if (format == NULL)
+    return 1;
+
+  ib_err_t err= ib_cfg_set_text("file_format", format);
+
+  if (err == DB_SUCCESS)
+  {
+    innobase_file_format_name= format;
+    return 0;
+  }
+  else
+    return 1;
+}
+
 static int haildb_init(drizzled::module::Context &context)
 {
   haildb_system_table_names.insert(std::string("HAILDB_SYS_TABLES"));
@@ -2878,33 +2896,6 @@
   innobase_print_verbose_log= (vm.count("disable-print-verbose-log")) ? false : true;
   srv_use_sys_malloc= (vm.count("use-internal-malloc")) ? false : true;
 
-  if (vm.count("fast-shutdown"))
-  {
-    if (innobase_fast_shutdown > 2)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of fast-shutdown"));
-      return 1;
-    }
-  }
-
-  if (vm.count("flush-log-at-trx-commit"))
-  {
-    if (srv_flush_log_at_trx_commit > 2)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of flush-log-at-trx-commit"));
-      return 1;
-    }
-  }
-
-  if (vm.count("force-recovery"))
-  {
-    if (innobase_force_recovery > 6)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of force-recovery"));
-      return 1;
-    }
-  }
-
   if (vm.count("log-file-size"))
   {
     if (haildb_log_file_size > INT64_MAX || haildb_log_file_size < 1*1024*1024L)
@@ -3008,21 +2999,6 @@
     }
   }
 
-  if (vm.count("file-format"))
-  {
-    innobase_file_format_name= const_cast<char *>(vm["file-format"].as<string>().c_str());
-  }
-
-  if (vm.count("log-group-home-dir"))
-  {
-    innobase_log_group_home_dir= const_cast<char *>(vm["log-group-home-dir"].as<string>().c_str());
-  }
-
-  if (vm.count("flush-method"))
-  {
-    innobase_unix_file_flush_method= const_cast<char *>(vm["flush-method"].as<string>().c_str());
-  }
-
   if (vm.count("data-file-path"))
   {
     haildb_data_file_path= const_cast<char *>(vm["data-file-path"].as<string>().c_str());
@@ -3042,9 +3018,9 @@
       goto haildb_error;
   }
 
-  if (innobase_log_group_home_dir)
+  if (vm.count("log-group-home-dir"))
   {
-    err= ib_cfg_set_text("log_group_home_dir", innobase_log_group_home_dir);
+    err= ib_cfg_set_text("log_group_home_dir", vm["log-group-home-dir"].as<string>().c_str());
     if (err != DB_SUCCESS)
       goto haildb_error;
   }
@@ -3116,18 +3092,21 @@
   if (err != DB_SUCCESS)
     goto haildb_error;
 
-  err= ib_cfg_set_int("flush_log_at_trx_commit", srv_flush_log_at_trx_commit);
+  err= ib_cfg_set_int("flush_log_at_trx_commit",
+                      static_cast<uint16_t>(srv_flush_log_at_trx_commit));
   if (err != DB_SUCCESS)
     goto haildb_error;
 
-  if (innobase_unix_file_flush_method)
+  if (vm.count("flush-method") != 0)
   {
-    err= ib_cfg_set_text("flush_method", innobase_unix_file_flush_method);
+    err= ib_cfg_set_text("flush_method", 
+                         vm["flush-method"].as<string>().c_str());
     if (err != DB_SUCCESS)
       goto haildb_error;
   }
 
-  err= ib_cfg_set_int("force_recovery", innobase_force_recovery);
+  err= ib_cfg_set_int("force_recovery",
+                      static_cast<uint16_t>(innobase_force_recovery));
   if (err != DB_SUCCESS)
     goto haildb_error;
 
@@ -3187,7 +3166,7 @@
   if (err != DB_SUCCESS)
     goto haildb_error;
 
-  err= ib_startup(innobase_file_format_name);
+  err= ib_startup(innobase_file_format_name.c_str());
   if (err != DB_SUCCESS)
     goto haildb_error;
 
@@ -3209,6 +3188,18 @@
   context.registerVariable(new sys_var_const_string_val("data_home_dir",
                                                 vm.count("data-home-dir") ?  vm["data-home-dir"].as<string>() : ""));
   context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("io_capacity", srv_io_capacity));
+  context.registerVariable(new sys_var_constrained_value_readonly<uint16_t>("fast_shutdown", innobase_fast_shutdown));
+  context.registerVariable(new sys_var_bool_ptr_readonly("file_per_table",
+                                                         &srv_file_per_table));
+  context.registerVariable(new sys_var_std_string("file-format",
+                                                  innobase_file_format_name,
+                                                  haildb_file_format_name_validate));
+  context.registerVariable(new sys_var_constrained_value_readonly<uint16_t>("flush_log_at_trx_commit", srv_flush_log_at_trx_commit));
+  context.registerVariable(new sys_var_const_string_val("flush_method",
+                                                vm.count("flush-method") ?  vm["flush-method"].as<string>() : ""));
+  context.registerVariable(new sys_var_constrained_value_readonly<uint16_t>("force_recovery", innobase_force_recovery));
+  context.registerVariable(new sys_var_const_string_val("log_group_home_dir",
+                                                vm.count("log-group-home-dir") ?  vm["log-group-home-dir"].as<string>() : ""));
 
   haildb_datadict_dump_func_initialize(context);
   config_table_function_initialize(context);
@@ -3227,9 +3218,9 @@
   ib_err_t err;
   ib_shutdown_t shutdown_flag= IB_SHUTDOWN_NORMAL;
 
-  if (innobase_fast_shutdown == 1)
+  if (static_cast<unsigned int>(innobase_fast_shutdown) == 1)
     shutdown_flag= IB_SHUTDOWN_NO_IBUFMERGE_PURGE;
-  else if (innobase_fast_shutdown == 2)
+  else if (static_cast<unsigned int>(innobase_fast_shutdown) == 2)
     shutdown_flag= IB_SHUTDOWN_NO_BUFPOOL_FLUSH;
 
   err= ib_shutdown(shutdown_flag);
@@ -3241,54 +3232,6 @@
 
 }
 
-static char haildb_file_format_name_storage[100];
-
-static int haildb_file_format_name_validate(Session*, drizzle_sys_var*,
-                                            void *save,
-                                            drizzle_value *value)
-{
-  ib_err_t err;
-  char buff[100];
-  int len= sizeof(buff);
-  const char *format= value->val_str(value, buff, &len);
-
-  *static_cast<const char**>(save)= NULL;
-
-  if (format == NULL)
-    return 1;
-
-  err= ib_cfg_set_text("file_format", format);
-
-  if (err == DB_SUCCESS)
-  {
-    strncpy(haildb_file_format_name_storage, format, sizeof(haildb_file_format_name_storage));;
-    haildb_file_format_name_storage[sizeof(haildb_file_format_name_storage)-1]= 0;
-
-    *static_cast<const char**>(save)= haildb_file_format_name_storage;
-    return 0;
-  }
-  else
-    return 1;
-}
-
-static void haildb_file_format_name_update(Session*, drizzle_sys_var*,
-                                           void *var_ptr,
-                                           const void *save)
-
-{
-  const char* format;
-
-  assert(var_ptr != NULL);
-  assert(save != NULL);
-
-  format= *static_cast<const char*const*>(save);
-
-  /* Format is already set in validate */
-  memmove(haildb_file_format_name_storage, format, sizeof(haildb_file_format_name_storage));;
-  haildb_file_format_name_storage[sizeof(haildb_file_format_name_storage)-1]= 0;
-
-  *static_cast<const char**>(var_ptr)= haildb_file_format_name_storage;
-}
 
 static void haildb_lru_old_blocks_pct_update(Session*, drizzle_sys_var*,
                                              void *,
@@ -3339,50 +3282,11 @@
     innobase_create_status_file= status_file_enabled;
 }
 
-static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
-  PLUGIN_VAR_OPCMDARG,
-  "Speeds up the shutdown process of the HailDB storage engine. Possible "
-  "values are 0, 1 (faster)"
-  " or 2 (fastest - crash-like)"
-  ".",
-  NULL, NULL, 1, 0, 2, 0);
-
-static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
-  PLUGIN_VAR_NOCMDARG,
-  "Stores each HailDB table to an .ibd file in the database dir.",
-  NULL, NULL, false);
-
-static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
-  PLUGIN_VAR_RQCMDARG,
-  "File format to use for new tables in .ibd files.",
-  haildb_file_format_name_validate,
-  haildb_file_format_name_update, "Barracuda");
-
-static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
-  PLUGIN_VAR_OPCMDARG,
-  "Set to 0 (write and flush once per second),"
-  " 1 (write and flush at each commit)"
-  " or 2 (write at commit, flush once per second).",
-  NULL, NULL, 1, 0, 2, 0);
-
-static DRIZZLE_SYSVAR_STR(flush_method, innobase_unix_file_flush_method,
-  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
-  "With which method to flush data.", NULL, NULL, NULL);
-
-static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
-  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
-  "Helps to save your data in case the disk image of the database becomes corrupt.",
-  NULL, NULL, 0, 0, 6, 0);
-
 static DRIZZLE_SYSVAR_STR(data_file_path, haildb_data_file_path,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
   "Path to individual files and their sizes.",
   NULL, NULL, NULL);
 
-static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
-  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
-  "Path to HailDB log files.", NULL, NULL, NULL);
-
 static DRIZZLE_SYSVAR_LONGLONG(log_file_size, haildb_log_file_size,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
   "Size of each log file in a log group.",
@@ -3494,31 +3398,28 @@
           po::value<io_capacity_constraint>(&srv_io_capacity)->default_value(200),
           N_("Number of IOPs the server can do. Tunes the background IO rate"));
   context("fast-shutdown",
-          po::value<unsigned long>(&innobase_fast_shutdown)->default_value(1),
+          po::value<trinary_constraint>(&innobase_fast_shutdown)->default_value(1),
           N_("Speeds up the shutdown process of the HailDB storage engine. Possible values are 0, 1 (faster) or 2 (fastest - crash-like)."));
   context("file-per-table",
           po::value<bool>(&srv_file_per_table)->default_value(false)->zero_tokens(),
           N_("Stores each HailDB table to an .ibd file in the database dir."));
   context("file-format",
-          po::value<string>(),
+          po::value<string>(&innobase_file_format_name)->default_value("Barracuda"),
           N_("File format to use for new tables in .ibd files."));
   context("flush-log-at-trx-commit",
-          po::value<unsigned long>(&srv_flush_log_at_trx_commit)->default_value(1),
+          po::value<trinary_constraint>(&srv_flush_log_at_trx_commit)->default_value(1),
           N_("Set to 0 (write and flush once per second),1 (write and flush at each commit) or 2 (write at commit, flush once per second)."));
   context("flush-method",
           po::value<string>(),
           N_("With which method to flush data."));
   context("force-recovery",
-          po::value<long>(&innobase_force_recovery)->default_value(0),
+          po::value<force_recovery_constraint>(&innobase_force_recovery)->default_value(0),
           N_("Helps to save your data in case the disk image of the database becomes corrupt."));
   context("data-file-path",
           po::value<string>(),
           N_("Path to individual files and their sizes."));
   context("log-group-home-dir",
           po::value<string>(),
-          N_("Path to individual files and their sizes."));
-  context("log-group-home-dir",
-          po::value<string>(),
           N_("Path to HailDB log files."));
   context("log-file-size",
           po::value<int64_t>(&haildb_log_file_size)->default_value(20*1024*1024L),
@@ -3569,13 +3470,6 @@
 }
 
 static drizzle_sys_var* innobase_system_variables[]= {
-  DRIZZLE_SYSVAR(fast_shutdown),
-  DRIZZLE_SYSVAR(file_per_table),
-  DRIZZLE_SYSVAR(file_format),
-  DRIZZLE_SYSVAR(flush_log_at_trx_commit),
-  DRIZZLE_SYSVAR(flush_method),
-  DRIZZLE_SYSVAR(force_recovery),
-  DRIZZLE_SYSVAR(log_group_home_dir),
   DRIZZLE_SYSVAR(data_file_path),
   DRIZZLE_SYSVAR(lock_wait_timeout),
   DRIZZLE_SYSVAR(log_file_size),

=== modified file 'plugin/haildb/tests/r/config_file_format.result'
--- plugin/haildb/tests/r/config_file_format.result	2010-09-23 06:31:07 +0000
+++ plugin/haildb/tests/r/config_file_format.result	2010-11-23 02:58:45 +0000
@@ -19,7 +19,7 @@
 NAME	TYPE	VALUE
 file_format	TEXT	Barracuda
 SET GLOBAL innodb_file_format='broccolini';
-ERROR HY000: Incorrect arguments to SET
+ERROR 42000: Variable 'innodb_file_format' can't be set to the value of 'broccolini'
 SHOW VARIABLES LIKE 'innodb_file_format';
 Variable_name	Value
 innodb_file_format	barracuda

=== modified file 'plugin/haildb/tests/t/config_file_format.test'
--- plugin/haildb/tests/t/config_file_format.test	2010-09-23 06:31:07 +0000
+++ plugin/haildb/tests/t/config_file_format.test	2010-11-23 02:58:45 +0000
@@ -6,7 +6,7 @@
 SET GLOBAL innodb_file_format='barracuda';
 SHOW VARIABLES LIKE 'innodb_file_format';
 SELECT * FROM DATA_DICTIONARY.HAILDB_CONFIGURATION WHERE NAME='file_format';
---error ER_WRONG_ARGUMENTS
+--error ER_WRONG_VALUE_FOR_VAR
 SET GLOBAL innodb_file_format='broccolini';
 SHOW VARIABLES LIKE 'innodb_file_format';
 SELECT * FROM DATA_DICTIONARY.HAILDB_CONFIGURATION WHERE NAME='file_format';

=== modified file 'plugin/mysql_unix_socket_protocol/protocol.cc'
--- plugin/mysql_unix_socket_protocol/protocol.cc	2010-10-29 18:10:56 +0000
+++ plugin/mysql_unix_socket_protocol/protocol.cc	2010-11-23 02:58:45 +0000
@@ -30,6 +30,7 @@
 #include <algorithm>
 #include <iostream>
 #include <boost/program_options.hpp>
+#include <boost/filesystem.hpp>
 #include <drizzled/module/option_map.h>
 
 #include <sys/un.h>
@@ -38,22 +39,24 @@
 
 #define DRIZZLE_UNIX_SOCKET_PATH "/tmp/mysql.socket"
 
-static std::string unix_socket_path(DRIZZLE_UNIX_SOCKET_PATH);
-
 namespace po= boost::program_options;
+namespace fs= boost::filesystem;
 using namespace drizzled;
 using namespace std;
 
 namespace mysql_unix_socket_protocol
 {
 
+static bool clobber= false;
+
 Protocol::~Protocol()
 {
+  fs::remove(unix_socket_path);
 }
 
 const char* Protocol::getHost(void) const
 {
-  return DRIZZLE_UNIX_SOCKET_PATH;
+  return unix_socket_path.file_string().c_str();
 }
 
 in_port_t Protocol::getPort(void) const
@@ -65,21 +68,28 @@
 {  
   const module::option_map &vm= context.getOptions();
 
-  if (vm.count("path"))
-  {
-    unix_socket_path.clear();
-    unix_socket_path.append(vm["path"].as<string>());
-  }
-
-  context.add(new Protocol("mysql_unix_socket_protocol", true));
+  fs::path uds_path(vm["path"].as<fs::path>());
+  if (not fs::exists(uds_path))
+  {
+    context.add(new Protocol("mysql_unix_socket_protocol",
+                             true,
+                             uds_path));
+    context.registerVariable(new sys_var_const_string_val("path", fs::system_complete(uds_path).file_string()));
+    context.registerVariable(new sys_var_bool_ptr_readonly("clobber", &clobber));
+  }
+  else
+  {
+    cerr << uds_path << _(" exists already. Do you have another Drizzle or "
+                          "MySQL running? Or perhaps the file is stale and "
+                          "should be removed?") << std::endl;
+    return 0;
+  }
 
   return 0;
 }
 
 bool Protocol::getFileDescriptors(std::vector<int> &fds)
 {
-  struct sockaddr_un servAddr;
-  socklen_t addrlen;
   int unix_sock;
 
   if ((unix_sock= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
@@ -88,34 +98,52 @@
     return false;
   }
 
+  // In case we restart and find something in our way we move it aside and
+  // then attempt to remove it.
+  if (clobber)
+  {
+    fs::path move_file(unix_socket_path.file_string() + ".old");
+    fs::rename(unix_socket_path, move_file);
+    unlink(move_file.file_string().c_str());
+  }
+
+
+  int arg= 1;
+
+  (void) setsockopt(unix_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&arg, sizeof(arg));
+  unlink(unix_socket_path.file_string().c_str());
+
+  struct sockaddr_un servAddr;
   memset(&servAddr, 0, sizeof(servAddr));
 
   servAddr.sun_family= AF_UNIX;
-  strcpy(servAddr.sun_path, unix_socket_path.c_str());
-  (void) unlink(unix_socket_path.c_str());
-
-  int arg= 1;
-
-  (void) setsockopt(unix_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&arg, sizeof(arg));
-
-  addrlen= sizeof(servAddr);
+  if (unix_socket_path.file_string().size() > sizeof(servAddr.sun_path))
+  {
+    std::cerr << "Unix Socket Path length too long. Must be under "
+      << sizeof(servAddr.sun_path) << " bytes." << endl;
+    return false;
+  }
+  memcpy(servAddr.sun_path, unix_socket_path.file_string().c_str(), sizeof(servAddr.sun_path)-1);
+
+  socklen_t addrlen= sizeof(servAddr);
   if (::bind(unix_sock, reinterpret_cast<sockaddr *>(&servAddr), addrlen) < 0)
   { 
-    std::cerr << "Can't start server : Bind on unix socket\n";
-    std::cerr << "Do you already have another of drizzled or mysqld running on socket: " << unix_socket_path << "?\n";
-    std::cerr << "Can't start server : UNIX Socket";
+    std::cerr << "Can't start server : Bind on unix socket." << std::endl;
+    std::cerr << "Do you already have another of drizzled or mysqld running on socket: " << unix_socket_path << "?" << std::endl;
+    std::cerr << "Can't start server : UNIX Socket" << std::endl;
 
     return false;
   }
 
-  if (listen(unix_sock,(int) 1000) < 0)
+  if (listen(unix_sock, (int) 1000) < 0)
   {
     std::cerr << "listen() on Unix socket failed with error " << errno << "\n";
   }
   else
   {
-    std::cerr << "Listening on " << unix_socket_path.c_str() << "\n";
+    std::cerr << "Listening on " << unix_socket_path << "\n";
   }
+  (void) unlink(unix_socket_path.file_string().c_str());
 
   fds.push_back(unix_sock);
 
@@ -126,14 +154,13 @@
 static void init_options(drizzled::module::option_context &context)
 {
   context("path",
-          po::value<string>()->default_value(unix_socket_path),
+          po::value<fs::path>()->default_value(DRIZZLE_UNIX_SOCKET_PATH),
           N_("Path used for MySQL UNIX Socket Protocol."));
+  context("clobber",
+          N_("Clobber socket file if one is there already."));
+
 }
 
-static drizzle_sys_var* sys_variables[]= {
-  NULL
-};
-
 } /* namespace mysql_unix_socket_protocol */
 
-DRIZZLE_PLUGIN(mysql_unix_socket_protocol::init, mysql_unix_socket_protocol::sys_variables, mysql_unix_socket_protocol::init_options);
+DRIZZLE_PLUGIN(mysql_unix_socket_protocol::init, NULL, mysql_unix_socket_protocol::init_options);

=== modified file 'plugin/mysql_unix_socket_protocol/protocol.h'
--- plugin/mysql_unix_socket_protocol/protocol.h	2010-10-28 14:56:34 +0000
+++ plugin/mysql_unix_socket_protocol/protocol.h	2010-11-23 02:58:45 +0000
@@ -27,6 +27,8 @@
 #include <drizzled/atomics.h>
 #include "drizzled/plugin/table_function.h"
 
+#include <boost/filesystem.hpp>
+
 #include "plugin/mysql_protocol/mysql_protocol.h"
 
 namespace mysql_unix_socket_protocol
@@ -34,9 +36,13 @@
 
 class Protocol: public ListenMySQLProtocol
 {
+  const boost::filesystem::path unix_socket_path;
 public:
-  Protocol(std::string name_arg, bool using_mysql41_protocol_arg):
-    ListenMySQLProtocol(name_arg, using_mysql41_protocol_arg)
+  Protocol(std::string name_arg,
+           bool using_mysql41_protocol_arg,
+           const boost::filesystem::path &unix_socket_path_arg) :
+    ListenMySQLProtocol(name_arg, using_mysql41_protocol_arg),
+    unix_socket_path(unix_socket_path_arg)
   { }
 
   ~Protocol();

=== modified file 'tests/lib/dtr_process.pl'
--- tests/lib/dtr_process.pl	2010-11-10 15:35:05 +0000
+++ tests/lib/dtr_process.pl	2010-11-23 02:58:45 +0000
@@ -356,7 +356,7 @@
     dtr_debug("  - drizzled " .
               "(pid: $srv->{pid}; " .
               "pid file: '$srv->{path_pid}'; " .
-              "socket: '$srv->{path_sock}'; ".
+              "socket: '$srv->{sockfile}'; ".
               "port: $srv->{port})");
 
     my $pid= dtr_server_shutdown($srv);
@@ -367,7 +367,7 @@
     push(@kill_pids,{
 		     pid      => $srv->{'pid'},
 		     pidfile  => $srv->{'path_pid'},
-		     sockfile => $srv->{'path_sock'},
+		     sockfile => $srv->{'sockfile'},
 		     port     => $srv->{'port'},
 		    });
     $srv->{'pid'}= 0; # Assume we are done with it
@@ -590,6 +590,11 @@
       {
         dtr_error("can't remove $srv->{'pidfile'}");
       }
+      if ( -f $srv->{'sockfile'} and ! unlink($srv->{'sockfile'}) and
+           -f $srv->{'sockfile'} )
+      {
+        dtr_error("can't remove $srv->{'sockfile'}");
+      }
     }
   }
 
@@ -608,6 +613,10 @@
     my $errors= 0;
     foreach my $srv ( @$spec )
     {
+      if ( $srv->{'sockfile'} )
+      {
+        unlink($srv->{'sockfile'});
+      }
       if ( $srv->{'pid'} )
       {
 	# Server has been hard killed, clean it's resources
@@ -682,11 +691,6 @@
   dtr_add_arg($args, "--password=");
   dtr_add_arg($args, "--silent");
 
-  if ( -e $srv->{'path_sock'} )
-  {
-    dtr_add_arg($args, "--socket=%s", $srv->{'path_sock'});
-  }
-
   if ( $srv->{'port'} )
   {
     dtr_add_arg($args, "--port=%s", $srv->{'port'});

=== modified file 'tests/test-run.pl'
--- tests/test-run.pl	2010-11-07 05:10:46 +0000
+++ tests/test-run.pl	2010-11-23 02:58:45 +0000
@@ -942,17 +942,6 @@
     }
   }
 
-  # On QNX, /tmp/dir/master.sock and /tmp/dir//master.sock seem to be
-  # considered different, so avoid the extra slash (/) in the socket
-  # paths.
-  my $sockdir = $opt_tmpdir;
-  $sockdir =~ s|/+$||;
-
-  # On some operating systems, there is a limit to the length of a
-  # UNIX domain socket's path far below PATH_MAX, so try to avoid long
-  # socket path names.
-  $sockdir = tempdir(CLEANUP => 0) if ( length($sockdir) >= 70 );
-
   $master->[0]=
   {
    pid            => 0,
@@ -961,7 +950,7 @@
    path_myddir    => "$opt_vardir/master-data",
    path_myerr     => "$opt_vardir/log/master.err",
    path_pid       => "$opt_vardir/run/master.pid",
-   path_sock      => "$sockdir/master.sock",
+   path_sock      => "$opt_vardir/master.sock",
    port           =>  $opt_master_myport,
    secondary_port =>  $opt_master_myport + $secondary_port_offset,
    start_timeout  =>  400, # enough time create innodb tables
@@ -977,7 +966,7 @@
    path_myddir    => "$opt_vardir/master1-data",
    path_myerr     => "$opt_vardir/log/master1.err",
    path_pid       => "$opt_vardir/run/master1.pid",
-   path_sock      => "$sockdir/master1.sock",
+   path_sock      => "$opt_vardir/master1.sock",
    port           => $opt_master_myport + 1,
    secondary_port => $opt_master_myport + 1 + $secondary_port_offset,
    start_timeout  => 400, # enough time create innodb tables
@@ -993,7 +982,7 @@
    path_myddir    => "$opt_vardir/slave-data",
    path_myerr     => "$opt_vardir/log/slave.err",
    path_pid       => "$opt_vardir/run/slave.pid",
-   path_sock      => "$sockdir/slave.sock",
+   path_sock      => "$opt_vardir/slave.sock",
    port           => $opt_slave_myport,
    secondary_port => $opt_slave_myport + $secondary_port_offset,
    start_timeout  => 400,
@@ -1009,7 +998,7 @@
    path_myddir    => "$opt_vardir/slave1-data",
    path_myerr     => "$opt_vardir/log/slave1.err",
    path_pid       => "$opt_vardir/run/slave1.pid",
-   path_sock      => "$sockdir/slave1.sock",
+   path_sock      => "$opt_vardir/slave1.sock",
    port           => $opt_slave_myport + 1,
    secondary_port => $opt_slave_myport + 1 + $secondary_port_offset,
    start_timeout  => 300,
@@ -1025,7 +1014,7 @@
    path_myddir    => "$opt_vardir/slave2-data",
    path_myerr     => "$opt_vardir/log/slave2.err",
    path_pid       => "$opt_vardir/run/slave2.pid",
-   path_sock      => "$sockdir/slave2.sock",
+   path_sock      => "$opt_vardir/slave2.sock",
    port           => $opt_slave_myport + 2,
    secondary_port => $opt_slave_myport + 2 + $secondary_port_offset,
    start_timeout  => 300,
@@ -2533,6 +2522,9 @@
   dtr_add_arg($args, "%s--datadir=%s", $prefix,
 	      $drizzled->{'path_myddir'});
 
+  dtr_add_arg($args, "%s--mysql-unix-socket-protocol.path=%s", $prefix,
+              $drizzled->{'path_sock'});
+
   # Check if "extra_opt" contains --skip-log-bin
   if ( $drizzled->{'type'} eq 'master' )
   {