Merge lp:~vjsamuel/drizzle/refactor-5-plugins into lp:~drizzle-trunk/drizzle/development

[Vijay Samuel]

=== modified file 'plugin/auth_http/auth_http.cc'
--- plugin/auth_http/auth_http.cc	2010-05-18 18:20:56 +0000
+++ plugin/auth_http/auth_http.cc	2010-07-17 14:34:41 +0000
@@ -23,15 +23,16 @@
 
 #include <string>
 #include <cassert>
-
+#include <boost/program_options.hpp>
+#include <drizzled/module/option_map.h>
 #include "drizzled/security_context.h"
 #include "drizzled/plugin/authentication.h"
 #include "drizzled/gettext.h"
-
+namespace po= boost::program_options;
 using namespace drizzled;
 using namespace std;
 
-static bool sysvar_auth_http_enable= false;
+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)
@@ -136,6 +137,12 @@
   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"));
+} 
+
 static DRIZZLE_SYSVAR_BOOL(
   enable,
   sysvar_auth_http_enable,
@@ -165,13 +172,13 @@
 DRIZZLE_DECLARE_PLUGIN
 {
   DRIZZLE_VERSION_ID,
-  "auth_http",
+  "auth-http",
   "0.1",
   "Mark Atwood",
   "HTTP based authenication.",
   PLUGIN_LICENSE_GPL,
   initialize, /* Plugin Init */
   auth_http_system_variables,
-  NULL    /* config options */
+  init_options    /* config options */
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/filtered_replicator/filtered_replicator.cc'
--- plugin/filtered_replicator/filtered_replicator.cc	2010-06-23 20:51:16 +0000
+++ plugin/filtered_replicator/filtered_replicator.cc	2010-07-17 14:34:41 +0000
@@ -43,10 +43,11 @@
 #include <drizzled/plugin.h>
 
 #include "filtered_replicator.h"
-
+#include <boost/program_options.hpp>
+#include <drizzled/module/option_map.h>
 #include <vector>
 #include <string>
-
+namespace po= boost::program_options;
 using namespace std;
 using namespace drizzled;
 
@@ -496,6 +497,28 @@
 
 static int init(module::Context &context)
 {
+  const module::option_map &vm= context.getOptions();
+  
+  if (vm.count("filteredschemas"))
+  {
+    sysvar_filtered_replicator_sch_filters= strdup(vm["filteredschemas"].as<string>().c_str());
+  }
+
+  else
+  {
+    sysvar_filtered_replicator_sch_filters= (char *)"";
+  }
+
+  if (vm.count("filteredtables"))
+  {
+    sysvar_filtered_replicator_tab_filters= strdup(vm["filteredtables"].as<string>().c_str());
+  }
+
+  else
+  {
+    sysvar_filtered_replicator_tab_filters= (char *)"";
+  }
+
   filtered_replicator= new(std::nothrow) 
     FilteredReplicator("filtered_replicator",
                        sysvar_filtered_replicator_sch_filters,
@@ -574,6 +597,16 @@
   }
 }
 
+static void init_options(drizzled::module::option_context &context)
+{
+  context("filteredschemas",
+          po::value<string>(),
+          N_("List of schemas to filter"));
+  context("filteredtables", 
+          po::value<string>(),
+          N_("List of tables to filter"));
+}
+
 static DRIZZLE_SYSVAR_STR(filteredschemas,
                           sysvar_filtered_replicator_sch_filters,
                           PLUGIN_VAR_OPCMDARG,
@@ -611,4 +644,4 @@
   NULL
 };
 
-DRIZZLE_PLUGIN(init, filtered_replicator_system_variables, NULL);
+DRIZZLE_PLUGIN(init, filtered_replicator_system_variables, init_options);

=== modified file 'plugin/hello_events/hello_events.cc'
--- plugin/hello_events/hello_events.cc	2010-05-21 16:22:35 +0000
+++ plugin/hello_events/hello_events.cc	2010-07-17 14:34:41 +0000
@@ -34,10 +34,11 @@
 #include "config.h"
 #include <string>
 #include <cstdio>
-
+#include <boost/program_options.hpp>
+#include <drizzled/module/option_map.h>
 #include "drizzled/session.h"
 #include "hello_events.h"
-
+namespace po= boost::program_options;
 using namespace drizzled;
 using namespace plugin;
 using namespace std;
@@ -285,6 +286,53 @@
 
 static int init(module::Context &context)
 {
+  const module::option_map &vm= context.getOptions();
+  if (vm.count("before-write-position"))
+  { 
+    if (sysvar_before_write_position < 1 || sysvar_before_write_position > INT32_MAX -1)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of before-write-position\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("before-update-position"))
+  { 
+    if (sysvar_before_update_position < 1 || sysvar_before_update_position > INT32_MAX -1)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of before-update-position\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("post-drop-db-position"))
+  { 
+    if (sysvar_post_drop_db_position > -1 || sysvar_post_drop_db_position < INT32_MIN+1)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of before-update-position\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("watch-databases"))
+  {
+    sysvar_db_list= strdup(vm["watch-databases"].as<string>().c_str());
+  }
+
+  else
+  {
+    sysvar_db_list= (char *)"";
+  }
+
+  if (vm.count("watch-tables"))
+  {
+    sysvar_table_list= strdup(vm["watch-tables"].as<string>().c_str());
+  }
+
+  else
+  {
+    sysvar_table_list= (char *)"";
+  }
   hello_events= new HelloEvents(PLUGIN_NAME);
 
   context.add(hello_events);
@@ -297,6 +345,28 @@
   return 0;
 }
 
+static void init_options(drizzled::module::option_context &context)
+{
+  context("watch-databases",
+          po::value<string>(),
+          N_("A comma delimited list of databases to watch"));
+  context("watch-tables",
+          po::value<string>(),
+          N_("A comma delimited list of databases to watch"));
+  context("enable",
+          po::value<bool>(&sysvar_hello_events_enabled)->default_value(false)->zero_tokens(),
+          N_("Enable Example Events Plugin"));
+  context("before-write-position",
+          po::value<int32_t>(&sysvar_before_write_position)->default_value(1),
+          N_("Before write row event observer call position"));
+  context("before-update-position",
+          po::value<int32_t>(&sysvar_before_update_position)->default_value(1),
+          N_("Before update row event observer call position"));
+  context("post-drop-db-position",
+          po::value<int32_t>(&sysvar_post_drop_db_position)->default_value(-1),
+          N_("After drop database event observer call position"));
+}
+
 static DRIZZLE_SYSVAR_STR(watch_databases,
                            sysvar_db_list,
                            PLUGIN_VAR_OPCMDARG,
@@ -374,6 +444,6 @@
   PLUGIN_LICENSE_BSD,
   init,   /* Plugin Init      */
   system_var, /* system variables */
-  NULL    /* config options   */
+  init_options    /* config options   */
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/logging_gearman/logging_gearman.cc'
--- plugin/logging_gearman/logging_gearman.cc	2010-05-18 18:20:56 +0000
+++ plugin/logging_gearman/logging_gearman.cc	2010-07-17 14:34:41 +0000
@@ -21,7 +21,8 @@
 #include <drizzled/plugin/logging.h>
 #include <drizzled/gettext.h>
 #include <drizzled/session.h>
-
+#include <boost/program_options.hpp>
+#include <drizzled/module/option_map.h>
 #include <libgearman/gearman.h>
 #include <limits.h>
 #include <sys/time.h>
@@ -31,12 +32,12 @@
 #include <cstdio>
 
 using namespace drizzled;
-
+namespace po= boost::program_options;
 
 /* TODO make this dynamic as needed */
 static const int MAX_MSG_LEN= 32*1024;
 
-static bool sysvar_logging_gearman_enable= false;
+static bool sysvar_logging_gearman_enable;
 static char* sysvar_logging_gearman_host= NULL;
 static char* sysvar_logging_gearman_function= NULL;
 
@@ -298,6 +299,13 @@
   return 0;
 }
 
+static void init_options(drizzled::module::option_context &context)
+{
+  context("enable",
+          po::value<bool>(&sysvar_logging_gearman_enable)->default_value(false)->zero_tokens(),
+          N_("Enable logging to a gearman server"));
+}
+
 static DRIZZLE_SYSVAR_BOOL(
                            enable,
                            sysvar_logging_gearman_enable,
@@ -335,13 +343,13 @@
 DRIZZLE_DECLARE_PLUGIN
 {
   DRIZZLE_VERSION_ID,
-    "logging_gearman",
+    "logging-gearman",
     "0.1",
     "Mark Atwood <[e-mail]>",
     N_("Log queries to a Gearman server"),
     PLUGIN_LICENSE_GPL,
     logging_gearman_plugin_init,
     logging_gearman_system_variables,
-    NULL
+    init_options
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/logging_query/logging_query.cc'
--- plugin/logging_query/logging_query.cc	2010-06-08 22:05:40 +0000
+++ plugin/logging_query/logging_query.cc	2010-07-17 14:34:41 +0000
@@ -29,9 +29,11 @@
 #include <fcntl.h>
 #include <string>
 #include <boost/format.hpp>
-
+#include <boost/program_options.hpp>
+#include <drizzled/module/option_map.h>
 #include <cstdio>
 
+namespace po= boost::program_options;
 using namespace drizzled;
 using namespace std;
 
@@ -302,12 +304,56 @@
 
 static int logging_query_plugin_init(drizzled::module::Context &context)
 {
+
+  const module::option_map &vm= context.getOptions();
+  if (vm.count("threshold-slow"))
+  {
+    if (sysvar_logging_query_threshold_slow > UINT32_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for threshold-slow"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("threshold-big-resultset"))
+  {
+    if (sysvar_logging_query_threshold_big_resultset > UINT32_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for threshold-big-resultset"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("threshold-big-examined"))
+  {
+    if (sysvar_logging_query_threshold_big_examined > UINT32_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for threshold-big-examined"));
+      exit(-1);
+    }
+  }
   handler= new Logging_query();
   context.add(handler);
 
   return 0;
 }
 
+static void init_options(drizzled::module::option_context &context)
+{
+  context("enable",
+          po::value<bool>(&sysvar_logging_query_enable)->default_value(false)->zero_tokens(),
+          N_("Enable logging to CSV file"));
+  context("threshold-slow",
+          po::value<unsigned long>(&sysvar_logging_query_threshold_slow)->default_value(0),
+          N_("Threshold for logging slow queries, in microseconds"));
+  context("threshold-big-resultset",
+          po::value<unsigned long>(&sysvar_logging_query_threshold_big_resultset)->default_value(0),
+          N_("Threshold for logging big queries, for rows returned"));
+  context("threshold-big-examined",
+          po::value<unsigned long>(&sysvar_logging_query_threshold_big_examined)->default_value(0),
+          N_("Threshold for logging big queries, for rows examined"));
+}
+
 static DRIZZLE_SYSVAR_BOOL(
   enable,
   sysvar_logging_query_enable,
@@ -384,13 +430,13 @@
 DRIZZLE_DECLARE_PLUGIN
 {
   DRIZZLE_VERSION_ID,
-  "logging_query",
+  "logging-query",
   "0.2",
   "Mark Atwood <[e-mail]>",
   N_("Log queries to a CSV file"),
   PLUGIN_LICENSE_GPL,
   logging_query_plugin_init,
   logging_query_system_variables,
-  NULL
+  init_options
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/transaction_log/tests/t/filtered_replicator-master.opt'
--- plugin/transaction_log/tests/t/filtered_replicator-master.opt	2010-04-05 16:06:01 +0000
+++ plugin/transaction_log/tests/t/filtered_replicator-master.opt	2010-07-17 14:34:41 +0000
@@ -1,1 +1,1 @@
---transaction-log-enable --transaction-log-use-replicator=filtered --scheduler=multi_thread --filtered-replicator-filteredschemas=notest
+--transaction-log-enable --transaction-log-use-replicator=filtered --scheduler=multi_thread --filtered-replicator.filteredschemas=notest