开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
repl_failsafe.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：26k
源码类别：

MySQL数据库

开发平台：

Visual C++

repl_failsafe.cpp：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB & Sasha
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include "mysql_priv.h"
  18. #ifdef HAVE_REPLICATION
  20. #include "repl_failsafe.h"
  21. #include "sql_repl.h"
  22. #include "slave.h"
  23. #include "log_event.h"
  24. #include <mysql.h>
  26. #define SLAVE_LIST_CHUNK 128
  27. #define SLAVE_ERRMSG_SIZE (FN_REFLEN+64)
  30. RPL_STATUS rpl_status=RPL_NULL;
  31. pthread_mutex_t LOCK_rpl_status;
  32. pthread_cond_t COND_rpl_status;
  33. HASH slave_list;
  35. const char *rpl_role_type[] = {"MASTER","SLAVE",NullS};
  36. TYPELIB rpl_role_typelib = {array_elements(rpl_role_type)-1,"",
  37.     rpl_role_type, NULL};
  39. const char* rpl_status_type[]=
  40. {
  41.   "AUTH_MASTER","ACTIVE_SLAVE","IDLE_SLAVE", "LOST_SOLDIER","TROOP_SOLDIER",
  42.   "RECOVERY_CAPTAIN","NULL",NullS
  43. };
  44. TYPELIB rpl_status_typelib= {array_elements(rpl_status_type)-1,"",
  45.      rpl_status_type, NULL};
  48. static Slave_log_event* find_slave_event(IO_CACHE* log,
  49.  const char* log_file_name,
  50.  char* errmsg);
  52. /*
  53.   All of the functions defined in this file which are not used (the ones to
  54.   handle failsafe) are not used; their code has not been updated for more than
  55.   one year now so should be considered as BADLY BROKEN. Do not enable it.
  56.   The used functions (to handle LOAD DATA FROM MASTER, plus some small
  57.   functions like register_slave()) are working.
  58. */
  60. static int init_failsafe_rpl_thread(THD* thd)
  61. {
  62.   DBUG_ENTER("init_failsafe_rpl_thread");
  63.   /*
  64.     thd->bootstrap is to report errors barely to stderr; if this code is
  65.     enable again one day, one should check if bootstrap is still needed (maybe
  66.     this thread has no other error reporting method).
  67.   */
  68.   thd->system_thread = thd->bootstrap = 1;
  69.   thd->host_or_ip= "";
  70.   my_net_init(&thd->net, 0);
  71.   thd->net.read_timeout = slave_net_timeout;
  72.   thd->max_client_packet_length=thd->net.max_packet;
  73.   thd->master_access= ~(ulong)0;
  74.   thd->priv_user = 0;
  75.   pthread_mutex_lock(&LOCK_thread_count);
  76.   thd->thread_id = thread_id++;
  77.   pthread_mutex_unlock(&LOCK_thread_count);
  79.   if (init_thr_lock() || thd->store_globals())
  80.   {
  81.     close_connection(thd, ER_OUT_OF_RESOURCES, 1); // is this needed?
  82.     statistic_increment(aborted_connects,&LOCK_status);
  83.     end_thread(thd,0);
  84.     DBUG_RETURN(-1);
  85.   }
  87. #if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
  88.   sigset_t set;
  89.   VOID(sigemptyset(&set)); // Get mask in use
  90.   VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
  91. #endif
  93.   thd->mem_root->free= thd->mem_root->used= 0;
  94.   if (thd->variables.max_join_size == HA_POS_ERROR)
  95.     thd->options|= OPTION_BIG_SELECTS;
  97.   thd->proc_info="Thread initialized";
  98.   thd->version=refresh_version;
  99.   thd->set_time();
  100.   DBUG_RETURN(0);
  101. }
  104. void change_rpl_status(RPL_STATUS from_status, RPL_STATUS to_status)
  105. {
  106.   pthread_mutex_lock(&LOCK_rpl_status);
  107.   if (rpl_status == from_status || rpl_status == RPL_ANY)
  108.     rpl_status = to_status;
  109.   pthread_cond_signal(&COND_rpl_status);
  110.   pthread_mutex_unlock(&LOCK_rpl_status);
  111. }
  114. #define get_object(p, obj) 
  115. {
  116.   uint len = (uint)*p++;  
  117.   if (p + len > p_end || len >= sizeof(obj)) 
  118.     goto err; 
  119.   strmake(obj,(char*) p,len); 
  120.   p+= len; 
  121. }
  124. static inline int cmp_master_pos(Slave_log_event* sev, LEX_MASTER_INFO* mi)
  125. {
  126.   return cmp_master_pos(sev->master_log, sev->master_pos, mi->log_file_name,
  127. mi->pos);
  128. }
  131. void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
  132. {
  133.   if (thd->server_id)
  134.   {
  135.     if (need_mutex)
  136.       pthread_mutex_lock(&LOCK_slave_list);
  138.     SLAVE_INFO* old_si;
  139.     if ((old_si = (SLAVE_INFO*)hash_search(&slave_list,
  140.    (byte*)&thd->server_id, 4)) &&
  141. (!only_mine || old_si->thd == thd))
  142.     hash_delete(&slave_list, (byte*)old_si);
  144.     if (need_mutex)
  145.       pthread_mutex_unlock(&LOCK_slave_list);
  146.   }
  147. }
  150. /*
  151.   Register slave in 'slave_list' hash table
  153.   RETURN VALUES
  154.   0 ok
  155.   1 Error.   Error message sent to client
  156. */
  158. int register_slave(THD* thd, uchar* packet, uint packet_length)
  159. {
  160.   int res;
  161.   SLAVE_INFO *si;
  162.   uchar *p= packet, *p_end= packet + packet_length;
  164.   if (check_access(thd, REPL_SLAVE_ACL, any_db,0,0,0))
  165.     return 1;
  166.   if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
  167.     goto err2;
  169.   thd->server_id= si->server_id= uint4korr(p);
  170.   p+= 4;
  171.   get_object(p,si->host);
  172.   get_object(p,si->user);
  173.   get_object(p,si->password);
  174.   if (p+10 > p_end)
  175.     goto err;
  176.   si->port= uint2korr(p);
  177.   p += 2;
  178.   si->rpl_recovery_rank= uint4korr(p);
  179.   p += 4;
  180.   if (!(si->master_id= uint4korr(p)))
  181.     si->master_id= server_id;
  182.   si->thd= thd;
  184.   pthread_mutex_lock(&LOCK_slave_list);
  185.   unregister_slave(thd,0,0);
  186.   res= my_hash_insert(&slave_list, (byte*) si);
  187.   pthread_mutex_unlock(&LOCK_slave_list);
  188.   return res;
  190. err:
  191.   my_free((gptr) si, MYF(MY_WME));
  192.   my_message(ER_UNKNOWN_ERROR, "Wrong parameters to function register_slave",
  193.      MYF(0));
  194. err2:
  195.   send_error(thd);
  196.   return 1;
  197. }
  199. extern "C" uint32
  200. *slave_list_key(SLAVE_INFO* si, uint* len,
  201. my_bool not_used __attribute__((unused)))
  202. {
  203.   *len = 4;
  204.   return &si->server_id;
  205. }
  207. extern "C" void slave_info_free(void *s)
  208. {
  209.   my_free((gptr) s, MYF(MY_WME));
  210. }
  212. void init_slave_list()
  213. {
  214.   hash_init(&slave_list, system_charset_info, SLAVE_LIST_CHUNK, 0, 0,
  215.     (hash_get_key) slave_list_key, (hash_free_key) slave_info_free, 0);
  216.   pthread_mutex_init(&LOCK_slave_list, MY_MUTEX_INIT_FAST);
  217. }
  219. void end_slave_list()
  220. {
  221.   /* No protection by a mutex needed as we are only called at shutdown */
  222.   if (hash_inited(&slave_list))
  223.   {
  224.     hash_free(&slave_list);
  225.     pthread_mutex_destroy(&LOCK_slave_list);
  226.   }
  227. }
  229. static int find_target_pos(LEX_MASTER_INFO *mi, IO_CACHE *log, char *errmsg)
  230. {
  231.   my_off_t log_pos =     (my_off_t) mi->pos;
  232.   uint32 target_server_id = mi->server_id;
  234.   for (;;)
  235.   {
  236.     Log_event* ev;
  237.     if (!(ev = Log_event::read_log_event(log, (pthread_mutex_t*) 0, 0)))
  238.     {
  239.       if (log->error > 0)
  240. strmov(errmsg, "Binary log truncated in the middle of event");
  241.       else if (log->error < 0)
  242. strmov(errmsg, "I/O error reading binary log");
  243.       else
  244. strmov(errmsg, "Could not find target event in the binary log");
  245.       return 1;
  246.     }
  248.     if (ev->log_pos >= log_pos && ev->server_id == target_server_id)
  249.     {
  250.       delete ev;
  251.       mi->pos = my_b_tell(log);
  252.       return 0;
  253.     }
  254.     delete ev;
  255.   }
  256.   /* Impossible */
  257. }
  259. /* 
  260.   Before 4.0.15 we had a member of THD called log_pos, it was meant for
  261.   failsafe replication code in repl_failsafe.cc which is disabled until
  262.   it is reworked. Event's log_pos used to be preserved through 
  263.   log-slave-updates to make code in repl_failsafe.cc work (this 
  264.   function, SHOW NEW MASTER); but on the other side it caused unexpected
  265.   values in Exec_Master_Log_Pos in A->B->C replication setup, 
  266.   synchronization problems in master_pos_wait(), ... So we 
  267.   (Dmitri & Guilhem) removed it.
  268.   
  269.   So for now this function is broken. 
  270. */
  272. int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
  273. {
  274.   LOG_INFO linfo;
  275.   char last_log_name[FN_REFLEN];
  276.   IO_CACHE log;
  277.   File file = -1, last_file = -1;
  278.   pthread_mutex_t *log_lock;
  279.   const char* errmsg_p;
  280.   Slave_log_event* sev = 0;
  281.   my_off_t last_pos = 0;
  282.   int error = 1;
  283.   int cmp_res;
  284.   LINT_INIT(cmp_res);
  285.   DBUG_ENTER("translate_master");
  287.   if (!mysql_bin_log.is_open())
  288.   {
  289.     strmov(errmsg,"Binary log is not open");
  290.     DBUG_RETURN(1);
  291.   }
  293.   if (!server_id_supplied)
  294.   {
  295.     strmov(errmsg, "Misconfigured master - server id was not set");
  296.     DBUG_RETURN(1);
  297.   }
  299.   if (mysql_bin_log.find_log_pos(&linfo, NullS, 1))
  300.   {
  301.     strmov(errmsg,"Could not find first log");
  302.     DBUG_RETURN(1);
  303.   }
  304.   thd->current_linfo = &linfo;
  306.   bzero((char*) &log,sizeof(log));
  307.   log_lock = mysql_bin_log.get_log_lock();
  308.   pthread_mutex_lock(log_lock);
  310.   for (;;)
  311.   {
  312.     if ((file=open_binlog(&log, linfo.log_file_name, &errmsg_p)) < 0)
  313.     {
  314.       strmov(errmsg, errmsg_p);
  315.       goto err;
  316.     }
  318.     if (!(sev = find_slave_event(&log, linfo.log_file_name, errmsg)))
  319.       goto err;
  321.     cmp_res = cmp_master_pos(sev, mi);
  322.     delete sev;
  324.     if (!cmp_res)
  325.     {
  326.       /* Copy basename */
  327.       fn_format(mi->log_file_name, linfo.log_file_name, "","",1);
  328.       mi->pos = my_b_tell(&log);
  329.       goto mi_inited;
  330.     }
  331.     else if (cmp_res > 0)
  332.     {
  333.       if (!last_pos)
  334.       {
  335. strmov(errmsg,
  336.        "Slave event in first log points past the target position");
  337. goto err;
  338.       }
  339.       end_io_cache(&log);
  340.       (void) my_close(file, MYF(MY_WME));
  341.       if (init_io_cache(&log, (file = last_file), IO_SIZE, READ_CACHE, 0, 0,
  342. MYF(MY_WME)))
  343.       {
  344. errmsg[0] = 0;
  345. goto err;
  346.       }
  347.       break;
  348.     }
  350.     strmov(last_log_name, linfo.log_file_name);
  351.     last_pos = my_b_tell(&log);
  353.     switch (mysql_bin_log.find_next_log(&linfo, 1)) {
  354.     case LOG_INFO_EOF:
  355.       if (last_file >= 0)
  356.        (void)my_close(last_file, MYF(MY_WME));
  357.       last_file = -1;
  358.       goto found_log;
  359.     case 0:
  360.       break;
  361.     default:
  362.       strmov(errmsg, "Error reading log index");
  363.       goto err;
  364.     }
  366.     end_io_cache(&log);
  367.     if (last_file >= 0)
  368.      (void) my_close(last_file, MYF(MY_WME));
  369.     last_file = file;
  370.   }
  372. found_log:
  373.   my_b_seek(&log, last_pos);
  374.   if (find_target_pos(mi,&log,errmsg))
  375.     goto err;
  376.   fn_format(mi->log_file_name, last_log_name, "","",1);  /* Copy basename */
  378. mi_inited:
  379.   error = 0;
  380. err:
  381.   pthread_mutex_unlock(log_lock);
  382.   end_io_cache(&log);
  383.   pthread_mutex_lock(&LOCK_thread_count);
  384.   thd->current_linfo = 0;
  385.   pthread_mutex_unlock(&LOCK_thread_count);
  386.   if (file >= 0)
  387.     (void) my_close(file, MYF(MY_WME));
  388.   if (last_file >= 0 && last_file != file)
  389.     (void) my_close(last_file, MYF(MY_WME));
  391.   DBUG_RETURN(error);
  392. }
  395. /*
  396.   Caller must delete result when done
  397. */
  399. static Slave_log_event* find_slave_event(IO_CACHE* log,
  400.  const char* log_file_name,
  401.  char* errmsg)
  402. {
  403.   Log_event* ev;
  404.   int i;
  405.   bool slave_event_found = 0;
  406.   LINT_INIT(ev);
  408.   for (i = 0; i < 2; i++)
  409.   {
  410.     if (!(ev = Log_event::read_log_event(log, (pthread_mutex_t*)0, 0)))
  411.     {
  412.       my_snprintf(errmsg, SLAVE_ERRMSG_SIZE,
  413.   "Error reading event in log '%s'",
  414.   (char*)log_file_name);
  415.       return 0;
  416.     }
  417.     if (ev->get_type_code() == SLAVE_EVENT)
  418.     {
  419.       slave_event_found = 1;
  420.       break;
  421.     }
  422.     delete ev;
  423.   }
  424.   if (!slave_event_found)
  425.   {
  426.     my_snprintf(errmsg, SLAVE_ERRMSG_SIZE,
  427. "Could not find slave event in log '%s'",
  428. (char*)log_file_name);
  429.     return 0;
  430.   }
  432.   return (Slave_log_event*)ev;
  433. }
  435. /*
  436.    This function is broken now. See comment for translate_master().
  437.  */
  439. int show_new_master(THD* thd)
  440. {
  441.   Protocol *protocol= thd->protocol;
  442.   DBUG_ENTER("show_new_master");
  443.   List<Item> field_list;
  444.   char errmsg[SLAVE_ERRMSG_SIZE];
  445.   LEX_MASTER_INFO* lex_mi= &thd->lex->mi;
  447.   errmsg[0]=0; // Safety
  448.   if (translate_master(thd, lex_mi, errmsg))
  449.   {
  450.     if (errmsg[0])
  451.       my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0),
  452.        "SHOW NEW MASTER", errmsg);
  453.     DBUG_RETURN(-1);
  454.   }
  455.   else
  456.   {
  457.     field_list.push_back(new Item_empty_string("Log_name", 20));
  458.     field_list.push_back(new Item_return_int("Log_pos", 10,
  459.      MYSQL_TYPE_LONGLONG));
  460.     if (protocol->send_fields(&field_list, 1))
  461.       DBUG_RETURN(-1);
  462.     protocol->prepare_for_resend();
  463.     protocol->store(lex_mi->log_file_name, &my_charset_bin);
  464.     protocol->store((ulonglong) lex_mi->pos);
  465.     if (protocol->write())
  466.       DBUG_RETURN(-1);
  467.     send_eof(thd);
  468.     DBUG_RETURN(0);
  469.   }
  470. }
  472. /*
  473.   Asks the master for the list of its other connected slaves.
  474.   This is for failsafe replication: 
  475.   in order for failsafe replication to work, the servers involved in
  476.   replication must know of each other. We accomplish this by having each
  477.   slave report to the master how to reach it, and on connection, each
  478.   slave receives information about where the other slaves are.
  480.   SYNOPSIS
  481.     update_slave_list()
  482.     mysql           pre-existing connection to the master
  483.     mi              master info
  485.   NOTES
  486.     mi is used only to give detailed error messages which include the
  487.     hostname/port of the master, the username used by the slave to connect to
  488.     the master.
  489.     If the user used by the slave to connect to the master does not have the
  490.     REPLICATION SLAVE privilege, it will pop in this function because
  491.     SHOW SLAVE HOSTS will fail on the master.
  493.   RETURN VALUES
  494.     1           error
  495.     0           success
  496.  */
  498. int update_slave_list(MYSQL* mysql, MASTER_INFO* mi)
  499. {
  500.   MYSQL_RES* res=0;
  501.   MYSQL_ROW row;
  502.   const char* error=0;
  503.   bool have_auth_info;
  504.   int port_ind;
  505.   DBUG_ENTER("update_slave_list");
  507.   if (mysql_real_query(mysql,"SHOW SLAVE HOSTS",16) ||
  508.       !(res = mysql_store_result(mysql)))
  509.   {
  510.     error= mysql_error(mysql);
  511.     goto err;
  512.   }
  514.   switch (mysql_num_fields(res)) {
  515.   case 5:
  516.     have_auth_info = 0;
  517.     port_ind=2;
  518.     break;
  519.   case 7:
  520.     have_auth_info = 1;
  521.     port_ind=4;
  522.     break;
  523.   default:
  524.     error= "the master returned an invalid number of fields for SHOW SLAVE 
  525. HOSTS";
  526.     goto err;
  527.   }
  529.   pthread_mutex_lock(&LOCK_slave_list);
  531.   while ((row= mysql_fetch_row(res)))
  532.   {
  533.     uint32 server_id;
  534.     SLAVE_INFO* si, *old_si;
  535.     server_id = atoi(row[0]);
  536.     if ((old_si= (SLAVE_INFO*)hash_search(&slave_list,
  537.   (byte*)&server_id,4)))
  538.       si = old_si;
  539.     else
  540.     {
  541.       if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
  542.       {
  543. error= "the slave is out of memory";
  544. pthread_mutex_unlock(&LOCK_slave_list);
  545. goto err;
  546.       }
  547.       si->server_id = server_id;
  548.       my_hash_insert(&slave_list, (byte*)si);
  549.     }
  550.     strmake(si->host, row[1], sizeof(si->host)-1);
  551.     si->port = atoi(row[port_ind]);
  552.     si->rpl_recovery_rank = atoi(row[port_ind+1]);
  553.     si->master_id = atoi(row[port_ind+2]);
  554.     if (have_auth_info)
  555.     {
  556.       strmake(si->user, row[2], sizeof(si->user)-1);
  557.       strmake(si->password, row[3], sizeof(si->password)-1);
  558.     }
  559.   }
  560.   pthread_mutex_unlock(&LOCK_slave_list);
  562. err:
  563.   if (res)
  564.     mysql_free_result(res);
  565.   if (error)
  566.   {
  567.     sql_print_error("While trying to obtain the list of slaves from the master 
  568. '%s:%d', user '%s' got the following error: '%s'", 
  569.                     mi->host, mi->port, mi->user, error);
  570.     DBUG_RETURN(1);
  571.   }
  572.   DBUG_RETURN(0);
  573. }
  576. int find_recovery_captain(THD* thd, MYSQL* mysql)
  577. {
  578.   return 0;
  579. }
  582. pthread_handler_decl(handle_failsafe_rpl,arg)
  583. {
  584.   DBUG_ENTER("handle_failsafe_rpl");
  585.   THD *thd = new THD;
  586.   thd->thread_stack = (char*)&thd;
  587.   MYSQL* recovery_captain = 0;
  588.   const char* msg;
  590.   pthread_detach_this_thread();
  591.   if (init_failsafe_rpl_thread(thd) || !(recovery_captain=mysql_init(0)))
  592.   {
  593.     sql_print_error("Could not initialize failsafe replication thread");
  594.     goto err;
  595.   }
  596.   pthread_mutex_lock(&LOCK_rpl_status);
  597.   msg= thd->enter_cond(&COND_rpl_status,
  598.                        &LOCK_rpl_status, "Waiting for request");
  599.   while (!thd->killed && !abort_loop)
  600.   {
  601.     bool break_req_chain = 0;
  602.     pthread_cond_wait(&COND_rpl_status, &LOCK_rpl_status);
  603.     thd->proc_info="Processing request";
  604.     while (!break_req_chain)
  605.     {
  606.       switch (rpl_status) {
  607.       case RPL_LOST_SOLDIER:
  608. if (find_recovery_captain(thd, recovery_captain))
  609.   rpl_status=RPL_TROOP_SOLDIER;
  610. else
  611.   rpl_status=RPL_RECOVERY_CAPTAIN;
  612. break_req_chain=1; /* for now until other states are implemented */
  613. break;
  614.       default:
  615. break_req_chain=1;
  616. break;
  617.       }
  618.     }
  619.   }
  620.   thd->exit_cond(msg);
  621. err:
  622.   if (recovery_captain)
  623.     mysql_close(recovery_captain);
  624.   delete thd;
  625.   my_thread_end();
  626.   pthread_exit(0);
  627.   DBUG_RETURN(0);
  628. }
  631. int show_slave_hosts(THD* thd)
  632. {
  633.   List<Item> field_list;
  634.   Protocol *protocol= thd->protocol;
  635.   DBUG_ENTER("show_slave_hosts");
  637.   field_list.push_back(new Item_return_int("Server_id", 10,
  638.    MYSQL_TYPE_LONG));
  639.   field_list.push_back(new Item_empty_string("Host", 20));
  640.   if (opt_show_slave_auth_info)
  641.   {
  642.     field_list.push_back(new Item_empty_string("User",20));
  643.     field_list.push_back(new Item_empty_string("Password",20));
  644.   }
  645.   field_list.push_back(new Item_return_int("Port", 7, MYSQL_TYPE_LONG));
  646.   field_list.push_back(new Item_return_int("Rpl_recovery_rank", 7,
  647.    MYSQL_TYPE_LONG));
  648.   field_list.push_back(new Item_return_int("Master_id", 10,
  649.    MYSQL_TYPE_LONG));
  651.   if (protocol->send_fields(&field_list, 1))
  652.     DBUG_RETURN(-1);
  654.   pthread_mutex_lock(&LOCK_slave_list);
  656.   for (uint i = 0; i < slave_list.records; ++i)
  657.   {
  658.     SLAVE_INFO* si = (SLAVE_INFO*) hash_element(&slave_list, i);
  659.     protocol->prepare_for_resend();
  660.     protocol->store((uint32) si->server_id);
  661.     protocol->store(si->host, &my_charset_bin);
  662.     if (opt_show_slave_auth_info)
  663.     {
  664.       protocol->store(si->user, &my_charset_bin);
  665.       protocol->store(si->password, &my_charset_bin);
  666.     }
  667.     protocol->store((uint32) si->port);
  668.     protocol->store((uint32) si->rpl_recovery_rank);
  669.     protocol->store((uint32) si->master_id);
  670.     if (protocol->write())
  671.     {
  672.       pthread_mutex_unlock(&LOCK_slave_list);
  673.       DBUG_RETURN(-1);
  674.     }
  675.   }
  676.   pthread_mutex_unlock(&LOCK_slave_list);
  677.   send_eof(thd);
  678.   DBUG_RETURN(0);
  679. }
  682. int connect_to_master(THD *thd, MYSQL* mysql, MASTER_INFO* mi)
  683. {
  684.   DBUG_ENTER("connect_to_master");
  686.   if (!mi->host || !*mi->host) /* empty host */
  687.   {
  688.     strmov(mysql->net.last_error, "Master is not configured");
  689.     DBUG_RETURN(1);
  690.   }
  691.   mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *) &slave_net_timeout);
  692.   mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, (char *) &slave_net_timeout);
  694. #ifdef HAVE_OPENSSL
  695.   if (mi->ssl)
  696.     mysql_ssl_set(mysql, 
  697.         mi->ssl_key[0]?mi->ssl_key:0,
  698.         mi->ssl_cert[0]?mi->ssl_cert:0,
  699.         mi->ssl_ca[0]?mi->ssl_ca:0, 
  700.         mi->ssl_capath[0]?mi->ssl_capath:0,
  701.         mi->ssl_cipher[0]?mi->ssl_cipher:0);
  702. #endif
  703.     
  704.   mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->csname);
  705.   mysql_options(mysql, MYSQL_SET_CHARSET_DIR, (char *) charsets_dir);
  706.   if (!mysql_real_connect(mysql, mi->host, mi->user, mi->password, 0,
  707. mi->port, 0, 0))
  708.     DBUG_RETURN(1);
  709.   DBUG_RETURN(0);
  710. }
  713. static inline void cleanup_mysql_results(MYSQL_RES* db_res,
  714.  MYSQL_RES** cur, MYSQL_RES** start)
  715. {
  716.   for (; cur >= start; --cur)
  717.   {
  718.     if (*cur)
  719.       mysql_free_result(*cur);
  720.   }
  721.   mysql_free_result(db_res);
  722. }
  725. static int fetch_db_tables(THD *thd, MYSQL *mysql, const char *db,
  726.    MYSQL_RES *table_res, MASTER_INFO *mi)
  727. {
  728.   MYSQL_ROW row;
  729.   for (row = mysql_fetch_row(table_res); row;
  730.        row = mysql_fetch_row(table_res))
  731.   {
  732.     TABLE_LIST table;
  733.     const char* table_name= row[0];
  734.     int error;
  735.     if (table_rules_on)
  736.     {
  737.       bzero((char*) &table, sizeof(table)); //just for safe
  738.       table.db= (char*) db;
  739.       table.real_name= (char*) table_name;
  740.       table.updating= 1;
  742.       if (!tables_ok(thd, &table))
  743. continue;
  744.     }
  745.     /* download master's table and overwrite slave's table */
  746.     if ((error= fetch_master_table(thd, db, table_name, mi, mysql, 1)))
  747.       return error;
  748.   }
  749.   return 0;
  750. }
  752. /*
  753.   Load all MyISAM tables from master to this slave.
  755.   REQUIREMENTS
  756.    - No active transaction (flush_relay_log_info would not work in this case)
  757. */
  759. int load_master_data(THD* thd)
  760. {
  761.   MYSQL mysql;
  762.   MYSQL_RES* master_status_res = 0;
  763.   int error = 0;
  764.   const char* errmsg=0;
  765.   int restart_thread_mask;
  766.   HA_CREATE_INFO create_info;
  768.   mysql_init(&mysql);
  770.   /*
  771.     We do not want anyone messing with the slave at all for the entire
  772.     duration of the data load.
  773.   */
  774.   pthread_mutex_lock(&LOCK_active_mi);
  775.   lock_slave_threads(active_mi);
  776.   init_thread_mask(&restart_thread_mask,active_mi,0 /*not inverse*/);
  777.   if (restart_thread_mask &&
  778.       (error=terminate_slave_threads(active_mi,restart_thread_mask,
  779.      1 /*skip lock*/)))
  780.   {
  781.     send_error(thd,error);
  782.     unlock_slave_threads(active_mi);
  783.     pthread_mutex_unlock(&LOCK_active_mi);
  784.     return 1;
  785.   }
  786.   
  787.   if (connect_to_master(thd, &mysql, active_mi))
  788.   {
  789.     net_printf(thd, error= ER_CONNECT_TO_MASTER,
  790.        mysql_error(&mysql));
  791.     goto err;
  792.   }
  794.   // now that we are connected, get all database and tables in each
  795.   {
  796.     MYSQL_RES *db_res, **table_res, **table_res_end, **cur_table_res;
  797.     uint num_dbs;
  799.     if (mysql_real_query(&mysql, "SHOW DATABASES", 14) ||
  800. !(db_res = mysql_store_result(&mysql)))
  801.     {
  802.       net_printf(thd, error = ER_QUERY_ON_MASTER,
  803.  mysql_error(&mysql));
  804.       goto err;
  805.     }
  807.     if (!(num_dbs = (uint) mysql_num_rows(db_res)))
  808.       goto err;
  809.     /*
  810.       In theory, the master could have no databases at all
  811.       and run with skip-grant
  812.     */
  814.     if (!(table_res = (MYSQL_RES**)thd->alloc(num_dbs * sizeof(MYSQL_RES*))))
  815.     {
  816.       net_printf(thd, error = ER_OUTOFMEMORY);
  817.       goto err;
  818.     }
  820.     /*
  821.       This is a temporary solution until we have online backup
  822.       capabilities - to be replaced once online backup is working
  823.       we wait to issue FLUSH TABLES WITH READ LOCK for as long as we
  824.       can to minimize the lock time.
  825.     */
  826.     if (mysql_real_query(&mysql, "FLUSH TABLES WITH READ LOCK", 27) ||
  827. mysql_real_query(&mysql, "SHOW MASTER STATUS",18) ||
  828. !(master_status_res = mysql_store_result(&mysql)))
  829.     {
  830.       net_printf(thd, error = ER_QUERY_ON_MASTER,
  831.  mysql_error(&mysql));
  832.       goto err;
  833.     }
  835.     /*
  836.       Go through every table in every database, and if the replication
  837.       rules allow replicating it, get it
  838.     */
  840.     table_res_end = table_res + num_dbs;
  842.     for (cur_table_res = table_res; cur_table_res < table_res_end;
  843.  cur_table_res++)
  844.     {
  845.       // since we know how many rows we have, this can never be NULL
  846.       MYSQL_ROW row = mysql_fetch_row(db_res);
  847.       char* db = row[0];
  849.       /*
  850. Do not replicate databases excluded by rules. We also test
  851. replicate_wild_*_table rules (replicate_wild_ignore_table='db1.%' will
  852. be considered as "ignore the 'db1' database as a whole, as it already
  853. works for CREATE DATABASE and DROP DATABASE).
  854. Also skip 'mysql' database - in most cases the user will
  855. mess up and not exclude mysql database with the rules when
  856. he actually means to - in this case, he is up for a surprise if
  857. his priv tables get dropped and downloaded from master
  858. TODO - add special option, not enabled
  859. by default, to allow inclusion of mysql database into load
  860. data from master
  861.       */
  863.       if (!db_ok(db, replicate_do_db, replicate_ignore_db) ||
  864.           !db_ok_with_wild_table(db) ||
  865.   !strcmp(db,"mysql"))
  866.       {
  867. *cur_table_res = 0;
  868. continue;
  869.       }
  871.       bzero((char*) &create_info, sizeof(create_info));
  872.       create_info.options= HA_LEX_CREATE_IF_NOT_EXISTS;
  874.       if (mysql_create_db(thd, db, &create_info, 1))
  875.       {
  876. send_error(thd, 0, 0);
  877. cleanup_mysql_results(db_res, cur_table_res - 1, table_res);
  878. goto err;
  879.       }
  881.       if (mysql_select_db(&mysql, db) ||
  882.   mysql_real_query(&mysql, "SHOW TABLES", 11) ||
  883.   !(*cur_table_res = mysql_store_result(&mysql)))
  884.       {
  885. net_printf(thd, error = ER_QUERY_ON_MASTER,
  886.    mysql_error(&mysql));
  887. cleanup_mysql_results(db_res, cur_table_res - 1, table_res);
  888. goto err;
  889.       }
  891.       if ((error = fetch_db_tables(thd,&mysql,db,*cur_table_res,active_mi)))
  892.       {
  893. // we do not report the error - fetch_db_tables handles it
  894. cleanup_mysql_results(db_res, cur_table_res, table_res);
  895. goto err;
  896.       }
  897.     }
  899.     cleanup_mysql_results(db_res, cur_table_res - 1, table_res);
  901.     // adjust replication coordinates from the master
  902.     if (master_status_res)
  903.     {
  904.       MYSQL_ROW row = mysql_fetch_row(master_status_res);
  906.       /*
  907. We need this check because the master may not be running with
  908. log-bin, but it will still allow us to do all the steps
  909. of LOAD DATA FROM MASTER - no reason to forbid it, really,
  910. although it does not make much sense for the user to do it
  911.       */
  912.       if (row && row[0] && row[1])
  913.       {
  914.         /*
  915.           If the slave's master info is not inited, we init it, then we write
  916.           the new coordinates to it. Must call init_master_info() *before*
  917.           setting active_mi, because init_master_info() sets active_mi with
  918.           defaults.
  919.         */
  920.         int error;
  922.         if (init_master_info(active_mi, master_info_file, relay_log_info_file, 
  923.      0, (SLAVE_IO | SLAVE_SQL)))
  924.           send_error(thd, ER_MASTER_INFO);
  925. strmake(active_mi->master_log_name, row[0],
  926. sizeof(active_mi->master_log_name));
  927. active_mi->master_log_pos= my_strtoll10(row[1], (char**) 0, &error);
  928.         /* at least in recent versions, the condition below should be false */
  929. if (active_mi->master_log_pos < BIN_LOG_HEADER_SIZE)
  930.   active_mi->master_log_pos = BIN_LOG_HEADER_SIZE;
  931.         /*
  932.           Relay log's IO_CACHE may not be inited (even if we are sure that some
  933.           host was specified; there could have been a problem when replication
  934.           started, which led to relay log's IO_CACHE to not be inited.
  935.         */
  936. flush_master_info(active_mi, 0);
  937.       }
  938.       mysql_free_result(master_status_res);
  939.     }
  941.     if (mysql_real_query(&mysql, "UNLOCK TABLES", 13))
  942.     {
  943.       net_printf(thd, error = ER_QUERY_ON_MASTER,
  944.  mysql_error(&mysql));
  945.       goto err;
  946.     }
  947.   }
  948.   thd->proc_info="purging old relay logs";
  949.   if (purge_relay_logs(&active_mi->rli,thd,
  950.        0 /* not only reset, but also reinit */,
  951.        &errmsg))
  952.   {
  953.     send_error(thd, 0, "Failed purging old relay logs");
  954.     unlock_slave_threads(active_mi);
  955.     pthread_mutex_unlock(&LOCK_active_mi);
  956.     return 1;
  957.   }
  958.   pthread_mutex_lock(&active_mi->rli.data_lock);
  959.   active_mi->rli.group_master_log_pos = active_mi->master_log_pos;
  960.   strmake(active_mi->rli.group_master_log_name,active_mi->master_log_name,
  961.   sizeof(active_mi->rli.group_master_log_name)-1);
  962.   /*
  963.      Cancel the previous START SLAVE UNTIL, as the fact to download
  964.      a new copy logically makes UNTIL irrelevant.
  965.   */
  966.   clear_until_condition(&active_mi->rli);
  968.   /*
  969.     No need to update rli.event* coordinates, they will be when the slave
  970.     threads start ; only rli.group* coordinates are necessary here.
  971.   */
  972.   flush_relay_log_info(&active_mi->rli);
  973.   pthread_cond_broadcast(&active_mi->rli.data_cond);
  974.   pthread_mutex_unlock(&active_mi->rli.data_lock);
  975.   thd->proc_info = "starting slave";
  976.   if (restart_thread_mask)
  977.   {
  978.     error=start_slave_threads(0 /* mutex not needed */,
  979.       1 /* wait for start */,
  980.       active_mi,master_info_file,relay_log_info_file,
  981.       restart_thread_mask);
  982.   }
  984. err:
  985.   unlock_slave_threads(active_mi);
  986.   pthread_mutex_unlock(&LOCK_active_mi);
  987.   thd->proc_info = 0;
  989.   mysql_close(&mysql); // safe to call since we always do mysql_init()
  990.   if (!error)
  991.     send_ok(thd);
  993.   return error;
  994. }
  996. #endif /* HAVE_REPLICATION */