bzr merge -r3890..3891 lp:codership-mysql/5.5

sql/CMakeLists.txt

@@ -50,6 +50,7 @@ IF(WITH_WSREP)
    wsrep_sst.cc
    wsrep_utils.cc
    wsrep_var.cc
+   wsrep_thd.cc
  )
  SET(WSREP_LIB wsrep)
 ENDIF()

sql/mdl.cc

@@ -24,6 +24,7 @@
 #include <mysql/psi/mysql_stage.h>
 #ifdef WITH_WSREP
 #include "wsrep_mysqld.h"
+#include "wsrep_thd.h"
 extern "C" my_thread_id wsrep_thd_thread_id(THD *thd);
 extern "C" char *wsrep_thd_query(THD *thd);
 void sql_print_information(const char *format, ...)

sql/mysqld.cc

@@ -73,6 +73,8 @@
 #include "debug_sync.h"
 #ifdef WITH_WSREP
 #include "wsrep_mysqld.h"
+#include "wsrep_thd.h"
+#include "wsrep_sst.h"
 ulong  wsrep_running_threads = 0; // # of currently running wsrep threads
 #endif
 #include "sql_callback.h"
@@ -741,7 +743,7 @@ mysql_mutex_t LOCK_wsrep_slave_threads;
 mysql_mutex_t LOCK_wsrep_desync;
 int wsrep_replaying= 0;
 static void wsrep_close_threads(THD* thd);
-#endif
+#endif /* WITH_WSREP */
 
 /* replication parameters, if master_host is not NULL, we are a slave */
 uint report_port= 0;
@@ -4467,26 +4469,26 @@ static int init_thread_environment()
   rpl_init_gtid_slave_state();
 #endif
 
-#ifdef WITH_WSREP 
-  mysql_mutex_init(key_LOCK_wsrep_ready, 
-		   &LOCK_wsrep_ready, MY_MUTEX_INIT_FAST);
+#ifdef WITH_WSREP
+  mysql_mutex_init(key_LOCK_wsrep_ready,
+                   &LOCK_wsrep_ready, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_COND_wsrep_ready, &COND_wsrep_ready, NULL);
-  mysql_mutex_init(key_LOCK_wsrep_sst, 
-		   &LOCK_wsrep_sst, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_wsrep_sst,
+                   &LOCK_wsrep_sst, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_COND_wsrep_sst, &COND_wsrep_sst, NULL);
-  mysql_mutex_init(key_LOCK_wsrep_sst_init, 
-		   &LOCK_wsrep_sst_init, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_wsrep_sst_init,
+                   &LOCK_wsrep_sst_init, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_COND_wsrep_sst_init, &COND_wsrep_sst_init, NULL);
-  mysql_mutex_init(key_LOCK_wsrep_rollback, 
-		   &LOCK_wsrep_rollback, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_wsrep_rollback,
+                   &LOCK_wsrep_rollback, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_COND_wsrep_rollback, &COND_wsrep_rollback, NULL);
-  mysql_mutex_init(key_LOCK_wsrep_replaying, 
-		   &LOCK_wsrep_replaying, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_wsrep_replaying,
+                   &LOCK_wsrep_replaying, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_COND_wsrep_replaying, &COND_wsrep_replaying, NULL);
-  mysql_mutex_init(key_LOCK_wsrep_slave_threads, 
-		   &LOCK_wsrep_slave_threads, MY_MUTEX_INIT_FAST);
-  mysql_mutex_init(key_LOCK_wsrep_desync, 
-		   &LOCK_wsrep_desync, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_wsrep_slave_threads,
+                   &LOCK_wsrep_slave_threads, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_wsrep_desync,
+                   &LOCK_wsrep_desync, MY_MUTEX_INIT_FAST);
 #endif
 
   DBUG_RETURN(0);
@@ -5109,7 +5111,7 @@ pthread_handler_t start_wsrep_THD(void *arg)
   THD *thd;
   wsrep_thd_processor_fun processor= (wsrep_thd_processor_fun)arg;
 
-  if (my_thread_init()) 
+  if (my_thread_init())
   {
     WSREP_ERROR("Could not initialize thread");
     return(NULL);
@@ -5172,7 +5174,7 @@ pthread_handler_t start_wsrep_THD(void *arg)
     statistic_increment(aborted_connects,&LOCK_status);
     MYSQL_CALLBACK(thread_scheduler, end_thread, (thd, 0));
     delete thd;
- 
+
     return(NULL);
   }
 
@@ -5230,42 +5232,6 @@ pthread_handler_t start_wsrep_THD(void *arg)
   return(NULL);
 }
 
-void wsrep_create_rollbacker()
-{
-  if (wsrep_provider && strcasecmp(wsrep_provider, "none"))
-  {
-    pthread_t hThread;
-    /* create rollbacker */
-    if (pthread_create( &hThread, &connection_attrib,
-			start_wsrep_THD, (void*)wsrep_rollback_process))
-      WSREP_WARN("Can't create thread to manage wsrep rollback");
-  }
-}
-
-void wsrep_create_appliers(long threads)
-{
-  if (!wsrep_connected)
-  {
-    /* see wsrep_replication_start() for the logic */
-    if (wsrep_cluster_address && strlen(wsrep_cluster_address) &&
-        wsrep_provider && strcasecmp(wsrep_provider, "none"))
-    {
-      WSREP_ERROR("Trying to launch slave threads before creating "
-                  "connection at '%s'", wsrep_cluster_address);
-      assert(0);
-    }
-    return;
-  }
-
-  long wsrep_threads=0;
-  pthread_t hThread;
-  while (wsrep_threads++ < threads) {
-    if (pthread_create(
-      &hThread, &connection_attrib,
-      start_wsrep_THD, (void*)wsrep_replication_process))
-      WSREP_WARN("Can't create thread to manage wsrep replication");
-  }
-}
 /**/
 static bool abort_replicated(THD *thd)
 {
@@ -5290,7 +5256,7 @@ WSREP_WARN("applier has wsrep_exec_mode = %d", thd->wsrep_exec_mode);
 
   if ( thd->slave_thread               || /* declared as mysql slave  */
        thd->system_thread              || /* declared as system thread */
-      !thd->vio_ok()                   || /* server internal thread */ 
+      !thd->vio_ok()                   || /* server internal thread */
        thd->wsrep_exec_mode==REPL_RECV || /* applier or replaying thread */
        thd->wsrep_applier              || /* wsrep slave applier */
       !thd->variables.wsrep_on)           /* client, but fenced outside wsrep */

sql/mysqld.h

@@ -240,7 +240,7 @@ extern PSI_mutex_key key_PAGE_lock, key_LOCK_sync, key_LOCK_active,
 #ifdef WITH_WSREP
 extern PSI_mutex_key key_LOCK_wsrep_thd;
 extern PSI_cond_key  key_COND_wsrep_thd;
-#endif /* HAVE_MMAP */
+#endif /* HAVE_WSREP */
 
 #ifdef HAVE_OPENSSL
 extern PSI_mutex_key key_LOCK_des_key_file;
@@ -580,8 +580,8 @@ enum options_mysqld
   OPT_WSREP_START_POSITION,
   OPT_WSREP_SST_AUTH,
   OPT_WSREP_RECOVER,
-#endif
   OPT_which_is_always_the_last
+#endif /* WITH_WSREP */
 };
 #endif
 
@@ -724,5 +724,9 @@ extern uint internal_tmp_table_max_key_segments;
 extern uint volatile global_disable_checkpoint;
 extern my_bool opt_help;
 
+#ifdef WITH_WSREP
+#include "my_pthread.h"
+pthread_handler_t start_wsrep_THD(void*);
+#endif /* WITH_WSREP */
 
 #endif /* MYSQLD_INCLUDED */

sql/sql_base.cc

@@ -63,7 +63,7 @@
 
 #ifdef WITH_WSREP
 #include "wsrep_mysqld.h"
-
+#include "wsrep_thd.h"
 #endif // WITH_WSREP
 
 bool

sql/sys_vars.cc

@@ -4063,7 +4063,8 @@ static Sys_var_tz Sys_time_zone(
        DEFAULT(&default_tz), NO_MUTEX_GUARD, IN_BINLOG);
 
 #ifdef WITH_WSREP
-#include "wsrep_mysqld.h"
+#include "wsrep_var.h"
+#include "wsrep_sst.h"
 
 static Sys_var_charptr Sys_wsrep_provider(
        "wsrep_provider", "Path to replication provider library",
@@ -4244,8 +4245,7 @@ static Sys_var_mybool Sys_wsrep_certify_nonPK(
 static Sys_var_mybool Sys_wsrep_causal_reads(
        "wsrep_causal_reads", "Enable \"strictly synchronous\" semantics for read operations",
        SESSION_VAR(wsrep_causal_reads), 
-       CMD_LINE(OPT_ARG), DEFAULT(FALSE)); 
-       //       ON_UPDATE(wsrep_causal_reads_update));
+       CMD_LINE(OPT_ARG), DEFAULT(FALSE));
 
 static const char *wsrep_OSU_method_names[]= { "TOI", "RSU", NullS };
 static Sys_var_enum Sys_wsrep_OSU_method(

sql/wsrep_mysqld.cc

@@ -17,6 +17,10 @@
 #include <sql_class.h>
 #include <sql_parse.h>
 #include "wsrep_priv.h"
+#include "wsrep_thd.h"
+#include "wsrep_sst.h"
+#include "wsrep_utils.h"
+#include "wsrep_var.h"
 #include <cstdio>
 #include <cstdlib>
 #include "log_event.h"
@@ -88,7 +92,6 @@ const char* wsrep_provider_version   = provider_version;
 const char* wsrep_provider_vendor    = provider_vendor;
 /* End wsrep status variables */
 
-
 wsrep_uuid_t     local_uuid   = WSREP_UUID_UNDEFINED;
 wsrep_seqno_t    local_seqno  = WSREP_SEQNO_UNDEFINED;
 wsp::node_status local_status;
@@ -99,14 +102,7 @@ long             wsrep_protocol_version = 2;
 // if there was no state gap on receiving first view event.
 static my_bool   wsrep_startup = TRUE;
 
-// action execute callback
-extern wsrep_status_t wsrep_apply_cb(void *ctx,
-                                     const void* buf, size_t buf_len,
-                                     wsrep_seqno_t global_seqno);
-
-extern wsrep_status_t wsrep_commit_cb  (void *ctx,
-                                        wsrep_seqno_t global_seqno,
-                                        bool commit);
+/* wsrep callbacks */
 
 static void wsrep_log_cb(wsrep_log_level_t level, const char *msg) {
   switch (level) {

sql/wsrep_mysqld.h

@@ -79,11 +79,6 @@ extern ulong       wsrep_retry_autocommit;
 extern my_bool     wsrep_auto_increment_control;
 extern my_bool     wsrep_drupal_282555_workaround;
 extern my_bool     wsrep_incremental_data_collection;
-extern const char* wsrep_sst_method;
-extern const char* wsrep_sst_receive_address;
-extern       char* wsrep_sst_auth;
-extern const char* wsrep_sst_donor;
-extern my_bool     wsrep_sst_donor_rejects_queries;
 extern const char* wsrep_start_position;
 extern long long   wsrep_max_ws_size;
 extern long        wsrep_max_ws_rows;
@@ -117,71 +112,21 @@ extern const char* wsrep_provider_vendor;
 extern int         wsrep_show_status(THD *thd, SHOW_VAR *var, char *buff);
 extern void        wsrep_free_status(THD *thd);
 
-#define WSREP_SST_ADDRESS_AUTO   "AUTO"
-#define WSREP_NODE_INCOMING_AUTO "AUTO"
 
-// MySQL variables funcs
+extern int   wsrep_init_vars();
+extern void  wsrep_provider_init       (const char* provider);
+extern void  wsrep_start_position_init (const char* position);
+extern void  wsrep_sst_auth_init       (const char* auth);
 
-#define CHECK_ARGS   (sys_var *self, THD* thd, set_var *var)
-#define UPDATE_ARGS  (sys_var *self, THD* thd, enum_var_type type)
-#define DEFAULT_ARGS (THD* thd, enum_var_type var_type)
-#define INIT_ARGS    (const char* opt)
-
-extern int  wsrep_init_vars();
-
-extern bool wsrep_on_update                  UPDATE_ARGS;
-extern void wsrep_causal_reads_update        UPDATE_ARGS;
-extern bool wsrep_start_position_check       CHECK_ARGS;
-extern bool wsrep_start_position_update      UPDATE_ARGS;
-extern void wsrep_start_position_init        INIT_ARGS;
-
-extern bool wsrep_provider_check             CHECK_ARGS;
-extern bool wsrep_provider_update            UPDATE_ARGS;
-extern void wsrep_provider_init              INIT_ARGS;
-
-extern bool wsrep_provider_options_check     CHECK_ARGS;
-extern bool wsrep_provider_options_update    UPDATE_ARGS;
-extern void wsrep_provider_options_init      INIT_ARGS;
-
-extern bool wsrep_cluster_address_check      CHECK_ARGS;
-extern bool wsrep_cluster_address_update     UPDATE_ARGS;
-extern void wsrep_cluster_address_init       INIT_ARGS;
-
-extern bool wsrep_cluster_name_check         CHECK_ARGS;
-extern bool wsrep_cluster_name_update        UPDATE_ARGS;
-
-extern bool wsrep_node_name_check            CHECK_ARGS;
-extern bool wsrep_node_name_update           UPDATE_ARGS;
-
-extern bool wsrep_node_address_check         CHECK_ARGS;
-extern bool wsrep_node_address_update        UPDATE_ARGS;
-extern void wsrep_node_address_init          INIT_ARGS;
-
-extern bool wsrep_sst_method_check           CHECK_ARGS;
-extern bool wsrep_sst_method_update          UPDATE_ARGS;
-extern void wsrep_sst_method_init            INIT_ARGS;
-
-extern bool wsrep_sst_receive_address_check  CHECK_ARGS;
-extern bool wsrep_sst_receive_address_update UPDATE_ARGS;
-
-extern bool wsrep_sst_auth_check             CHECK_ARGS;
-extern bool wsrep_sst_auth_update            UPDATE_ARGS;
-extern void wsrep_sst_auth_init              INIT_ARGS;
-
-extern bool wsrep_sst_donor_check            CHECK_ARGS;
-extern bool wsrep_sst_donor_update           UPDATE_ARGS;
-
-extern bool wsrep_slave_threads_check        CHECK_ARGS;
-extern bool wsrep_slave_threads_update       UPDATE_ARGS;
-
-extern bool wsrep_desync_check               CHECK_ARGS;
-extern bool wsrep_desync_update              UPDATE_ARGS;
-
-extern bool  wsrep_before_SE(); // initialize wsrep before storage
-                                // engines (true) or after (false)
 extern int   wsrep_init();
 extern void  wsrep_deinit();
 extern void  wsrep_recover();
+extern bool  wsrep_before_SE(); // initialize wsrep before storage
+                                // engines (true) or after (false)
+/* wsrep initialization sequence at startup
+ * @param before wsrep_before_SE() value */
+extern void wsrep_init_startup(bool before);
+
 
 
 
@@ -215,17 +160,11 @@ extern "C" void wsrep_thd_awake(THD* bf_thd, THD *thd, my_bool signal);
 
 
 
-/* wsrep initialization sequence at startup
- * @param first wsrep_before_SE() value */
-extern void wsrep_init_startup(bool before);
-
 extern void wsrep_close_client_connections(my_bool wait_to_end);
 extern int  wsrep_wait_committing_connections_close(int wait_time);
 extern void wsrep_close_applier(THD *thd);
 extern void wsrep_wait_appliers_close(THD *thd);
 extern void wsrep_close_applier_threads(int count);
-extern void wsrep_create_appliers(long threads = wsrep_slave_threads);
-extern void wsrep_create_rollbacker();
 extern void wsrep_kill_mysql(THD *thd);
 
 /* new defines */
@@ -286,18 +225,6 @@ extern wsrep_seqno_t wsrep_locked_seqno;
     if (victim_thd) WSREP_LOG_CONFLICT_THD(victim_thd, "Victim thread");       \
   }
 
-/*! Synchronizes applier thread start with init thread */
-extern void wsrep_sst_grab();
-/*! Init thread waits for SST completion */
-extern bool wsrep_sst_wait();
-/*! Signals wsrep that initialization is complete, writesets can be applied */
-extern void wsrep_sst_continue();
-
-extern void wsrep_SE_init_grab(); /*! grab init critical section */
-extern void wsrep_SE_init_wait(); /*! wait for SE init to complete */
-extern void wsrep_SE_init_done(); /*! signal that SE init is complte */
-extern void wsrep_SE_initialized(); /*! mark SE initialization complete */
-
 extern void wsrep_ready_wait();
 
 enum wsrep_trx_status {
@@ -311,17 +238,10 @@ wsrep_run_wsrep_commit(THD *thd, handlerton *hton, bool all);
 class Ha_trx_info;
 struct THD_TRANS;
 void wsrep_register_hton(THD* thd, bool all);
-
-void wsrep_replication_process(THD *thd);
-void wsrep_rollback_process(THD *thd);
 void wsrep_brute_force_killer(THD *thd);
 int  wsrep_hire_brute_force_killer(THD *thd, uint64_t trx_id);
+
 extern "C" bool wsrep_consistency_check(void *thd_ptr);
-//extern "C" int wsrep_thd_is_brute_force(void *thd_ptr);
-extern int wsrep_thd_is_brute_force(void *thd_ptr);
-extern "C" int wsrep_abort_thd(void *bf_thd_ptr, void *victim_thd_ptr, 
-                               my_bool signal);
-extern "C" int wsrep_thd_in_locking_session(void *thd_ptr);
 
 /* this is visible for client build so that innodb plugin gets this */
 typedef struct wsrep_aborting_thd {

sql/wsrep_notify.cc

@@ -15,6 +15,7 @@
 
 #include <mysqld.h>
 #include "wsrep_priv.h"
+#include "wsrep_utils.h"
 
 const char* wsrep_notify_cmd="";
 
@@ -64,7 +65,7 @@ void wsrep_notify_status (wsrep_member_status_t    status,
   {
     char uuid_str[40];
 
-    wsrep_uuid_print (&view->uuid, uuid_str, sizeof(uuid_str));
+    wsrep_uuid_print (&view->state_id.uuid, uuid_str, sizeof(uuid_str));
     cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off,
                          " --uuid %s", uuid_str);
 

sql/wsrep_notify.cc.moved

+/* Copyright 2010 Codership Oy <http://www.codership.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include <mysqld.h>
+#include "wsrep_priv.h"
+
+const char* wsrep_notify_cmd="";
+
+static const char* _status_str(wsrep_member_status_t status)
+{
+  switch (status)
+  {
+  case WSREP_MEMBER_UNDEFINED: return "Undefined";
+  case WSREP_MEMBER_JOINER:    return "Joiner";
+  case WSREP_MEMBER_DONOR:     return "Donor";
+  case WSREP_MEMBER_JOINED:    return "Joined";
+  case WSREP_MEMBER_SYNCED:    return "Synced";
+  default:                     return "Error(?)";
+  }
+}
+
+void wsrep_notify_status (wsrep_member_status_t    status,
+                          const wsrep_view_info_t* view)
+{
+  if (!wsrep_notify_cmd || 0 == strlen(wsrep_notify_cmd))
+  {
+    WSREP_INFO("wsrep_notify_cmd is not defined, skipping notification.");
+    return;
+  }
+
+  char  cmd_buf[1 << 16]; // this can be long
+  long  cmd_len = sizeof(cmd_buf) - 1;
+  char* cmd_ptr = cmd_buf;
+  long  cmd_off = 0;
+
+  cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off, "%s",
+                       wsrep_notify_cmd);
+
+  if (status >= WSREP_MEMBER_UNDEFINED && status < WSREP_MEMBER_ERROR)
+  {
+    cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off, " --status %s",
+                         _status_str(status));
+  }
+  else
+  {
+    /* here we preserve provider error codes */
+    cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off,
+                         " --status 'Error(%d)'", status);
+  }
+
+  if (0 != view)
+  {
+    char uuid_str[40];
+
+    wsrep_uuid_print (&view->uuid, uuid_str, sizeof(uuid_str));
+    cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off,
+                         " --uuid %s", uuid_str);
+
+    cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off,
+                         " --primary %s", view->view >= 0 ? "yes" : "no");
+
+    cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off,
+                         " --index %d", view->my_idx);
+
+    cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off, " --members");
+
+    for (int i = 0; i < view->memb_num; i++)
+    {
+      wsrep_uuid_print (&view->members[i].id, uuid_str, sizeof(uuid_str));
+      cmd_off += snprintf (cmd_ptr + cmd_off, cmd_len - cmd_off,
+                           "%c%s/%s/%s", i > 0 ? ',' : ' ',
+                           uuid_str, view->members[i].name,
+                           view->members[i].incoming);
+    }
+  }
+
+  if (cmd_off == cmd_len)
+  {
+    WSREP_ERROR("Notification buffer too short (%ld). Aborting notification.",
+               cmd_len);
+    return;
+  }
+
+  wsp::process p(cmd_ptr, "r");
+
+  p.wait();
+  int err = p.error();
+
+  if (err)
+  {
+    WSREP_ERROR("Notification command failed: %d (%s): \"%s\"",
+                err, strerror(err), cmd_ptr);
+  }
+}
+

sql/wsrep_priv.h

@@ -26,208 +26,30 @@
 #include <pthread.h>
 #include <cstdio>
 
-extern void    wsrep_ready_set (my_bool x);
+void    wsrep_ready_set (my_bool x);
 
-extern ssize_t wsrep_sst_prepare   (void** msg);
-extern int     wsrep_sst_donate_cb (void* app_ctx,
-                                    void* recv_ctx,
-                                    const void* msg, size_t msg_len,
-                                    const wsrep_uuid_t* current_uuid,
-                                    wsrep_seqno_t       current_seqno,
-                                    const char* state, size_t state_len,
-                                    bool bypass);
-
-extern size_t guess_ip (char* buf, size_t buf_len);
-extern size_t guess_address(char* buf, size_t buf_len);
+ssize_t wsrep_sst_prepare   (void** msg);
+wsrep_cb_status wsrep_sst_donate_cb (void* app_ctx,
+                                     void* recv_ctx,
+                                     const void* msg, size_t msg_len,
+                                     const wsrep_gtid_t* state_id,
+                                     const char* state, size_t state_len,
+                                     bool bypass);
 
 extern wsrep_uuid_t  local_uuid;
 extern wsrep_seqno_t local_seqno;
 
+// a helper function
+void wsrep_sst_received(wsrep_t*, const wsrep_uuid_t*, wsrep_seqno_t,
+                               const void*, size_t);
 /*! SST thread signals init thread about sst completion */
-extern void wsrep_sst_complete(const wsrep_uuid_t* uuid, wsrep_seqno_t, bool);
+void wsrep_sst_complete(const wsrep_uuid_t*, wsrep_seqno_t, bool);
 
 extern void wsrep_notify_status (wsrep_member_status_t new_status,
                                  const wsrep_view_info_t* view = 0);
 
-namespace wsp {
-class node_status
-{
-public:
-  node_status() : status(WSREP_MEMBER_UNDEFINED) {}
-  void set(wsrep_member_status_t new_status,
-           const wsrep_view_info_t* view = 0)
-  {
-    if (status != new_status || 0 != view)
-    {
-      wsrep_notify_status(new_status, view);
-      status = new_status;
-    }
-  }
-  wsrep_member_status_t get() const { return status; }
-private:
-  wsrep_member_status_t status;
-};
-} /* namespace wsp */
-
-extern wsp::node_status local_status;
-
-namespace wsp {
-/* A small class to run external programs. */
-class process
-{
-private:
-    const char* const str_;
-    FILE*       io_;
-    int         err_;
-    pid_t       pid_;
-
-public:
-/*! @arg type is a pointer to a null-terminated string which  must  contain
-         either  the  letter  'r'  for  reading  or the letter 'w' for writing.
- */
-    process  (const char* cmd, const char* type);
-    ~process ();
-
-    FILE* pipe () { return io_;  }
-    int   error() { return err_; }
-    int   wait ();
-    const char* cmd() { return str_; }
-};
-#ifdef REMOVED
-class lock
-{
-  pthread_mutex_t* const mtx_;
-
-public:
-
-  lock (pthread_mutex_t* mtx) : mtx_(mtx)
-  {
-    int err = pthread_mutex_lock (mtx_);
-
-    if (err)
-    {
-      WSREP_ERROR("Mutex lock failed: %s", strerror(err));
-      abort();
-    }
-  }
-
-  virtual ~lock ()
-  {
-    int err = pthread_mutex_unlock (mtx_);
-
-    if (err)
-    {
-      WSREP_ERROR("Mutex unlock failed: %s", strerror(err));
-      abort();
-    }
-  }
-
-  inline void wait (pthread_cond_t* cond)
-  {
-    pthread_cond_wait (cond, mtx_);
-  }
-
-private:
-
-  lock (const lock&);
-  lock& operator=(const lock&);
-
-};
-
-class monitor
-{
-  int             mutable refcnt;
-  pthread_mutex_t mutable mtx;
-  pthread_cond_t  mutable cond;
-
-public:
-
-  monitor() : refcnt(0)
-  {
-    pthread_mutex_init (&mtx, NULL);
-    pthread_cond_init  (&cond, NULL);
-  }
-
-  ~monitor()
-  {
-    pthread_mutex_destroy (&mtx);
-    pthread_cond_destroy  (&cond);
-  }
-
-  void enter() const
-  {
-    lock l(&mtx);
-
-    while (refcnt)
-    {
-      l.wait(&cond);
-    }
-    refcnt++;
-  }
-
-  void leave() const
-  {
-    lock l(&mtx);
-
-    refcnt--;
-    if (refcnt == 0)
-    {
-      pthread_cond_signal (&cond);
-    }
-  }
-
-private:
-
-  monitor (const monitor&);
-  monitor& operator= (const monitor&);
-};
-
-class critical
-{
-  const monitor& mon;
-
-public:
-
-  critical(const monitor& m) : mon(m) { mon.enter(); }
-
-  ~critical() { mon.leave(); }
-
-private:
-
-  critical (const critical&);
-  critical& operator= (const critical&);
-};
-#endif
-
-class thd
-{
-  class thd_init
-  {
-  public:
-    thd_init()  { my_thread_init(); }
-    ~thd_init() { my_thread_end();  }
-  }
-  init;
-
-  thd (const thd&);
-  thd& operator= (const thd&);
-
-public:
-
-  thd(my_bool wsrep_on);
-  ~thd();
-  THD* const ptr;
-};
+/* binlog-related stuff */
+int wsrep_write_cache(IO_CACHE *cache, uchar **buf, size_t *buf_len);
 
-class string
-{
-public:
-    string() : string_(0) {}
-    void set(char* str) { if (string_) free (string_); string_ = str; }
-    ~string() { set (0); }
-private:
-    char* string_;
-};
 
-} // namespace wsrep
 #endif /* WSREP_PRIV_H */

sql/wsrep_priv.h.moved

+/* Copyright 2010 Codership Oy <http://www.codership.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+//! @file declares symbols private to wsrep integration layer
+
+#ifndef WSREP_PRIV_H
+#define WSREP_PRIV_H
+
+#include "wsrep_mysqld.h"
+#include "../wsrep/wsrep_api.h"
+
+#include <log.h>
+#include <pthread.h>
+#include <cstdio>
+
+extern void    wsrep_ready_set (my_bool x);
+
+extern ssize_t wsrep_sst_prepare   (void** msg);
+extern int     wsrep_sst_donate_cb (void* app_ctx,
+                                    void* recv_ctx,
+                                    const void* msg, size_t msg_len,
+                                    const wsrep_uuid_t* current_uuid,
+                                    wsrep_seqno_t       current_seqno,
+                                    const char* state, size_t state_len,
+                                    bool bypass);
+
+extern size_t guess_ip (char* buf, size_t buf_len);
+extern size_t guess_address(char* buf, size_t buf_len);
+
+extern wsrep_uuid_t  local_uuid;
+extern wsrep_seqno_t local_seqno;
+
+/*! SST thread signals init thread about sst completion */
+extern void wsrep_sst_complete(const wsrep_uuid_t* uuid, wsrep_seqno_t, bool);
+
+extern void wsrep_notify_status (wsrep_member_status_t new_status,
+                                 const wsrep_view_info_t* view = 0);
+
+namespace wsp {
+class node_status
+{
+public:
+  node_status() : status(WSREP_MEMBER_UNDEFINED) {}
+  void set(wsrep_member_status_t new_status,
+           const wsrep_view_info_t* view = 0)
+  {
+    if (status != new_status || 0 != view)
+    {
+      wsrep_notify_status(new_status, view);
+      status = new_status;
+    }
+  }
+  wsrep_member_status_t get() const { return status; }
+private:
+  wsrep_member_status_t status;
+};
+} /* namespace wsp */
+
+extern wsp::node_status local_status;
+
+namespace wsp {
+/* A small class to run external programs. */
+class process
+{
+private:
+    const char* const str_;
+    FILE*       io_;
+    int         err_;
+    pid_t       pid_;
+
+public:
+/*! @arg type is a pointer to a null-terminated string which  must  contain
+         either  the  letter  'r'  for  reading  or the letter 'w' for writing.
+ */
+    process  (const char* cmd, const char* type);
+    ~process ();
+
+    FILE* pipe () { return io_;  }
+    int   error() { return err_; }
+    int   wait ();
+    const char* cmd() { return str_; }
+};
+#ifdef REMOVED
+class lock
+{
+  pthread_mutex_t* const mtx_;
+
+public:
+
+  lock (pthread_mutex_t* mtx) : mtx_(mtx)
+  {
+    int err = pthread_mutex_lock (mtx_);
+
+    if (err)
+    {
+      WSREP_ERROR("Mutex lock failed: %s", strerror(err));
+      abort();
+    }
+  }
+
+  virtual ~lock ()
+  {
+    int err = pthread_mutex_unlock (mtx_);
+
+    if (err)
+    {
+      WSREP_ERROR("Mutex unlock failed: %s", strerror(err));
+      abort();
+    }
+  }
+
+  inline void wait (pthread_cond_t* cond)
+  {
+    pthread_cond_wait (cond, mtx_);
+  }
+
+private:
+
+  lock (const lock&);
+  lock& operator=(const lock&);
+
+};
+
+class monitor
+{
+  int             mutable refcnt;
+  pthread_mutex_t mutable mtx;
+  pthread_cond_t  mutable cond;
+
+public:
+
+  monitor() : refcnt(0)
+  {
+    pthread_mutex_init (&mtx, NULL);
+    pthread_cond_init  (&cond, NULL);
+  }
+
+  ~monitor()
+  {
+    pthread_mutex_destroy (&mtx);
+    pthread_cond_destroy  (&cond);
+  }
+
+  void enter() const
+  {
+    lock l(&mtx);
+
+    while (refcnt)
+    {
+      l.wait(&cond);
+    }
+    refcnt++;
+  }
+
+  void leave() const
+  {
+    lock l(&mtx);
+
+    refcnt--;
+    if (refcnt == 0)
+    {
+      pthread_cond_signal (&cond);
+    }
+  }
+
+private:
+
+  monitor (const monitor&);
+  monitor& operator= (const monitor&);
+};
+
+class critical
+{
+  const monitor& mon;
+
+public:
+
+  critical(const monitor& m) : mon(m) { mon.enter(); }
+
+  ~critical() { mon.leave(); }
+
+private:
+
+  critical (const critical&);
+  critical& operator= (const critical&);
+};
+#endif
+
+class thd
+{
+  class thd_init
+  {
+  public:
+    thd_init()  { my_thread_init(); }
+    ~thd_init() { my_thread_end();  }
+  }
+  init;
+
+  thd (const thd&);
+  thd& operator= (const thd&);
+
+public:
+
+  thd(my_bool wsrep_on);
+  ~thd();
+  THD* const ptr;
+};
+
+class string
+{
+public:
+    string() : string_(0) {}
+    void set(char* str) { if (string_) free (string_); string_ = str; }
+    ~string() { set (0); }
+private:
+    char* string_;
+};
+
+} // namespace wsrep
+#endif /* WSREP_PRIV_H */

sql/wsrep_sst.cc

@@ -13,6 +13,8 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
+#include "wsrep_sst.h"
+
 #include <mysqld.h>
 #include <sql_class.h>
 #include <set_var.h>
@@ -20,6 +22,7 @@
 #include <sql_reload.h>
 #include <sql_parse.h>
 #include "wsrep_priv.h"
+#include "wsrep_utils.h"
 #include <cstdio>
 #include <cstdlib>
 
@@ -58,7 +61,6 @@ const char* wsrep_sst_donor           = "";
 
 // container for real auth string
 static const char* sst_auth_real      = NULL;
-
 my_bool wsrep_sst_donor_rejects_queries = FALSE;
 
 bool wsrep_sst_method_check (sys_var *self, THD* thd, set_var* var)

sql/wsrep_sst.h

+/* Copyright (C) 2013 Codership Oy <info@codership.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
+
+#ifndef WSREP_SST_H
+#define WSREP_SST_H
+
+#include <mysql.h> // my_bool
+
+/* system variables */
+extern const char* wsrep_sst_method;
+extern const char* wsrep_sst_receive_address;
+extern const char* wsrep_sst_donor;
+extern       char* wsrep_sst_auth;
+extern    my_bool  wsrep_sst_donor_rejects_queries;
+
+/*! Synchronizes applier thread start with init thread */
+extern void wsrep_sst_grab();
+/*! Init thread waits for SST completion */
+extern bool wsrep_sst_wait();
+/*! Signals wsrep that initialization is complete, writesets can be applied */
+extern void wsrep_sst_continue();
+
+extern void wsrep_SE_init_grab();   /*! grab init critical section */
+extern void wsrep_SE_init_wait();   /*! wait for SE init to complete */
+extern void wsrep_SE_init_done();   /*! signal that SE init is complte */
+extern void wsrep_SE_initialized(); /*! mark SE initialization complete */
+
+#endif /* WSREP_SST_H */

sql/wsrep_thd.h

+/* Copyright (C) 2013 Codership Oy <info@codership.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
+
+#ifndef WSREP_THD_H
+#define WSREP_THD_H
+
+#include "sql_class.h"
+
+void wsrep_client_rollback(THD *thd);
+void wsrep_replay_transaction(THD *thd);
+void wsrep_create_appliers(long threads);
+void wsrep_create_rollbacker();
+
+extern "C" int  wsrep_thd_is_brute_force(void *thd_ptr);
+extern "C" int  wsrep_abort_thd(void *bf_thd_ptr, void *victim_thd_ptr,
+                                my_bool signal);
+extern "C" int  wsrep_thd_in_locking_session(void *thd_ptr);
+
+#endif /* WSREP_THD_H */

sql/wsrep_utils.cc

@@ -20,6 +20,10 @@
 #define _GNU_SOURCE // POSIX_SPAWN_USEVFORK flag
 #endif
 
+#include "wsrep_utils.h"
+#include "wsrep_mysqld.h"
+//#include "wsrep_api.h"
+//#include "wsrep_priv.h"
 #include <spawn.h>    // posix_spawn()
 #include <unistd.h>   // pipe()
 #include <errno.h>    // errno

sql/wsrep_utils.h

+/* Copyright (C) 2013 Codership Oy <info@codership.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
+
+#ifndef WSREP_UTILS_H
+#define WSREP_UTILS_H
+
+#include "wsrep_priv.h"
+
+unsigned int wsrep_check_ip (const char* addr);
+size_t wsrep_guess_ip (char* buf, size_t buf_len);
+size_t wsrep_guess_address(char* buf, size_t buf_len);
+
+namespace wsp {
+class node_status
+{
+public:
+  node_status() : status(WSREP_MEMBER_UNDEFINED) {}
+  void set(wsrep_member_status_t new_status,
+           const wsrep_view_info_t* view = 0)
+  {
+    if (status != new_status || 0 != view)
+    {
+      wsrep_notify_status(new_status, view);
+      status = new_status;
+    }
+  }
+  wsrep_member_status_t get() const { return status; }
+private:
+  wsrep_member_status_t status;
+};
+} /* namespace wsp */
+
+extern wsp::node_status local_status;
+
+namespace wsp {
+/* A small class to run external programs. */
+class process
+{
+private:
+    const char* const str_;
+    FILE*       io_;
+    int         err_;
+    pid_t       pid_;
+
+public:
+/*! @arg type is a pointer to a null-terminated string which  must  contain
+         either  the  letter  'r'  for  reading  or the letter 'w' for writing.
+ */
+    process  (const char* cmd, const char* type);
+    ~process ();
+
+    FILE* pipe () { return io_;  }
+    int   error() { return err_; }
+    int   wait ();
+    const char* cmd() { return str_; }
+};
+
+class thd
+{
+  class thd_init
+  {
+  public:
+    thd_init()  { my_thread_init(); }
+    ~thd_init() { my_thread_end();  }
+  }
+  init;
+
+  thd (const thd&);
+  thd& operator= (const thd&);
+
+public:
+
+  thd(my_bool wsrep_on);
+  ~thd();
+  THD* const ptr;
+};
+
+class string
+{
+public:
+    string() : string_(0) {}
+    void set(char* str) { if (string_) free (string_); string_ = str; }
+    ~string() { set (0); }
+private:
+    char* string_;
+};
+
+#ifdef REMOVED
+class lock
+{
+  pthread_mutex_t* const mtx_;
+
+public:
+
+  lock (pthread_mutex_t* mtx) : mtx_(mtx)
+  {
+    int err = pthread_mutex_lock (mtx_);
+
+    if (err)
+    {
+      WSREP_ERROR("Mutex lock failed: %s", strerror(err));
+      abort();
+    }
+  }
+
+  virtual ~lock ()
+  {
+    int err = pthread_mutex_unlock (mtx_);
+
+    if (err)
+    {
+      WSREP_ERROR("Mutex unlock failed: %s", strerror(err));
+      abort();
+    }
+  }
+
+  inline void wait (pthread_cond_t* cond)
+  {
+    pthread_cond_wait (cond, mtx_);
+  }
+
+private:
+
+  lock (const lock&);
+  lock& operator=(const lock&);
+
+};
+
+class monitor
+{
+  int             mutable refcnt;
+  pthread_mutex_t mutable mtx;
+  pthread_cond_t  mutable cond;
+
+public:
+
+  monitor() : refcnt(0)
+  {
+    pthread_mutex_init (&mtx, NULL);
+    pthread_cond_init  (&cond, NULL);
+  }
+
+  ~monitor()
+  {
+    pthread_mutex_destroy (&mtx);
+    pthread_cond_destroy  (&cond);
+  }
+
+  void enter() const
+  {
+    lock l(&mtx);
+
+    while (refcnt)
+    {
+      l.wait(&cond);
+    }
+    refcnt++;
+  }
+
+  void leave() const
+  {
+    lock l(&mtx);
+
+    refcnt--;
+    if (refcnt == 0)
+    {
+      pthread_cond_signal (&cond);
+    }
+  }
+
+private:
+
+  monitor (const monitor&);
+  monitor& operator= (const monitor&);
+};
+
+class critical
+{
+  const monitor& mon;
+
+public:
+
+  critical(const monitor& m) : mon(m) { mon.enter(); }
+
+  ~critical() { mon.leave(); }
+
+private:
+
+  critical (const critical&);
+  critical& operator= (const critical&);
+};
+#endif
+
+} // namespace wsrep
+
+#endif /* WSREP_UTILS_H */

sql/wsrep_var.cc

@@ -13,12 +13,15 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
+#include "wsrep_var.h"
+
 #include <mysqld.h>
 #include <sql_class.h>
 #include <sql_plugin.h>
 #include <set_var.h>
 #include <sql_acl.h>
 #include "wsrep_priv.h"
+#include "wsrep_thd.h"
 #include <my_dir.h>
 #include <cstdio>
 #include <cstdlib>
@@ -157,7 +160,7 @@ void wsrep_start_position_init (const char* val)
   if (NULL == val || wsrep_start_position_verify (val))
   {
     WSREP_ERROR("Bad initial value for wsrep_start_position: %s", 
-		(val ? val : ""));
+                (val ? val : ""));
     return;
   }
 
@@ -173,7 +176,7 @@ static bool refresh_provider_options()
   {
     if (wsrep_provider_options) my_free((void *)wsrep_provider_options);
     wsrep_provider_options = (char*)my_memdup(opts, strlen(opts) + 1, 
-					      MYF(MY_WME));
+                                              MYF(MY_WME));
   }
   else
   {

sql/wsrep_var.h

+/* Copyright (C) 2013 Codership Oy <info@codership.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
+
+#ifndef WSREP_VAR_H
+#define WSREP_VAR_H
+
+#define WSREP_NODE_INCOMING_AUTO "AUTO"
+
+// MySQL variables funcs
+
+#include "sql_priv.h"
+class sys_var;
+class set_var;
+class THD;
+
+#define CHECK_ARGS   (sys_var *self, THD* thd, set_var *var)
+#define UPDATE_ARGS  (sys_var *self, THD* thd, enum_var_type type)
+#define DEFAULT_ARGS (THD* thd, enum_var_type var_type)
+#define INIT_ARGS    (const char* opt)
+
+extern bool wsrep_on_update                  UPDATE_ARGS;
+extern void wsrep_causal_reads_update        UPDATE_ARGS;
+extern bool wsrep_start_position_check       CHECK_ARGS;
+extern bool wsrep_start_position_update      UPDATE_ARGS;
+extern void wsrep_start_position_init        INIT_ARGS;
+
+extern bool wsrep_provider_check             CHECK_ARGS;
+extern bool wsrep_provider_update            UPDATE_ARGS;
+extern void wsrep_provider_init              INIT_ARGS;
+
+extern bool wsrep_provider_options_check     CHECK_ARGS;
+extern bool wsrep_provider_options_update    UPDATE_ARGS;
+extern void wsrep_provider_options_init      INIT_ARGS;
+
+extern bool wsrep_cluster_address_check      CHECK_ARGS;
+extern bool wsrep_cluster_address_update     UPDATE_ARGS;
+extern void wsrep_cluster_address_init       INIT_ARGS;
+
+extern bool wsrep_cluster_name_check         CHECK_ARGS;
+extern bool wsrep_cluster_name_update        UPDATE_ARGS;
+
+extern bool wsrep_node_name_check            CHECK_ARGS;
+extern bool wsrep_node_name_update           UPDATE_ARGS;
+
+extern bool wsrep_node_address_check         CHECK_ARGS;
+extern bool wsrep_node_address_update        UPDATE_ARGS;
+extern void wsrep_node_address_init          INIT_ARGS;
+
+extern bool wsrep_sst_method_check           CHECK_ARGS;
+extern bool wsrep_sst_method_update          UPDATE_ARGS;
+extern void wsrep_sst_method_init            INIT_ARGS;
+
+extern bool wsrep_sst_receive_address_check  CHECK_ARGS;
+extern bool wsrep_sst_receive_address_update UPDATE_ARGS;
+
+extern bool wsrep_sst_auth_check             CHECK_ARGS;
+extern bool wsrep_sst_auth_update            UPDATE_ARGS;
+extern void wsrep_sst_auth_init              INIT_ARGS;
+
+extern bool wsrep_sst_donor_check            CHECK_ARGS;
+extern bool wsrep_sst_donor_update           UPDATE_ARGS;
+
+extern bool wsrep_slave_threads_check        CHECK_ARGS;
+extern bool wsrep_slave_threads_update       UPDATE_ARGS;
+
+extern bool wsrep_desync_check               CHECK_ARGS;
+extern bool wsrep_desync_update              UPDATE_ARGS;
+
+#endif /* WSREP_VAR_H */