slave.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:21k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000-2003 MySQL AB
  2.    
  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.
  7.    
  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.
  12.    
  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 */
  16. #ifdef HAVE_REPLICATION
  17. #ifndef SLAVE_H
  18. #define SLAVE_H
  19. #include "mysql.h"
  20. #include "my_list.h"
  21. #define SLAVE_NET_TIMEOUT  3600
  22. #define MAX_SLAVE_ERRMSG   1024
  23. #define MAX_SLAVE_ERROR    2000
  24. /*****************************************************************************
  25.   MySQL Replication
  26.   Replication is implemented via two types of threads:
  27.     I/O Thread - One of these threads is started for each master server.
  28.                  They maintain a connection to their master server, read log
  29.                  events from the master as they arrive, and queues them into
  30.                  a single, shared relay log file.  A MASTER_INFO struct
  31.                  represents each of these threads.
  32.     SQL Thread - One of these threads is started and reads from the relay log
  33.                  file, executing each event.  A RELAY_LOG_INFO struct
  34.                  represents this thread.
  35.   Buffering in the relay log file makes it unnecessary to reread events from
  36.   a master server across a slave restart.  It also decouples the slave from
  37.   the master where long-running updates and event logging are concerned--ie
  38.   it can continue to log new events while a slow query executes on the slave.
  39. *****************************************************************************/
  40. /*
  41.   MUTEXES in replication:
  42.   LOCK_active_mi: [note: this was originally meant for multimaster, to switch
  43.   from a master to another, to protect active_mi] It is used to SERIALIZE ALL
  44.   administrative commands of replication: START SLAVE, STOP SLAVE, CHANGE
  45.   MASTER, RESET SLAVE, end_slave() (when mysqld stops) [init_slave() does not
  46.   need it it's called early]. Any of these commands holds the mutex from the
  47.   start till the end. This thus protects us against a handful of deadlocks
  48.   (consider start_slave_thread() which, when starting the I/O thread, releases
  49.   mi->run_lock, keeps rli->run_lock, and tries to re-acquire mi->run_lock).
  50.   Currently active_mi never moves (it's created at startup and deleted at
  51.   shutdown, and not changed: it always points to the same MASTER_INFO struct),
  52.   because we don't have multimaster. So for the moment, mi does not move, and
  53.   mi->rli does not either.
  54.   In MASTER_INFO: run_lock, data_lock
  55.   run_lock protects all information about the run state: slave_running, and the
  56.   existence of the I/O thread (to stop/start it, you need this mutex).
  57.   data_lock protects some moving members of the struct: counters (log name,
  58.   position) and relay log (MYSQL_LOG object).
  59.   In RELAY_LOG_INFO: run_lock, data_lock
  60.   see MASTER_INFO
  61.   
  62.   Order of acquisition: if you want to have LOCK_active_mi and a run_lock, you
  63.   must acquire LOCK_active_mi first.
  64.   In MYSQL_LOG: LOCK_log, LOCK_index of the binlog and the relay log
  65.   LOCK_log: when you write to it. LOCK_index: when you create/delete a binlog
  66.   (so that you have to update the .index file).
  67. */
  68. extern ulong master_retry_count;
  69. extern MY_BITMAP slave_error_mask;
  70. extern bool use_slave_mask;
  71. extern char* slave_load_tmpdir;
  72. extern my_string master_info_file,relay_log_info_file;
  73. extern my_string opt_relay_logname, opt_relaylog_index_name;
  74. extern my_bool opt_skip_slave_start, opt_reckless_slave;
  75. extern my_bool opt_log_slave_updates;
  76. extern ulonglong relay_log_space_limit;
  77. struct st_master_info;
  78. enum enum_binlog_formats {
  79.   BINLOG_FORMAT_CURRENT=0, /* 0 is important for easy 'if (mi->old_format)' */
  80.   BINLOG_FORMAT_323_LESS_57, 
  81.   BINLOG_FORMAT_323_GEQ_57 };
  82. /*
  83.   3 possible values for MASTER_INFO::slave_running and
  84.   RELAY_LOG_INFO::slave_running.
  85.   The values 0,1,2 are very important: to keep the diff small, I didn't
  86.   substitute places where we use 0/1 with the newly defined symbols. So don't change
  87.   these values.
  88.   The same way, code is assuming that in RELAY_LOG_INFO we use only values
  89.   0/1.
  90.   I started with using an enum, but
  91.   enum_variable=1; is not legal so would have required many line changes.
  92. */
  93. #define MYSQL_SLAVE_NOT_RUN         0
  94. #define MYSQL_SLAVE_RUN_NOT_CONNECT 1
  95. #define MYSQL_SLAVE_RUN_CONNECT     2
  96. /****************************************************************************
  97.   Replication SQL Thread
  98.   st_relay_log_info contains:
  99.     - the current relay log
  100.     - the current relay log offset
  101.     - master log name
  102.     - master log sequence corresponding to the last update
  103.     - misc information specific to the SQL thread
  104.   st_relay_log_info is initialized from the slave.info file if such exists.
  105.   Otherwise, data members are intialized with defaults. The initialization is
  106.   done with init_relay_log_info() call.
  107.   The format of slave.info file:
  108.   relay_log_name
  109.   relay_log_pos
  110.   master_log_name
  111.   master_log_pos
  112.   To clean up, call end_relay_log_info()
  113. *****************************************************************************/
  114. typedef struct st_relay_log_info
  115. {
  116.   /*** The following variables can only be read when protect by data lock ****/
  117.   /*
  118.     info_fd - file descriptor of the info file. set only during
  119.     initialization or clean up - safe to read anytime
  120.     cur_log_fd - file descriptor of the current read  relay log
  121.   */
  122.   File info_fd,cur_log_fd;
  123.   /*
  124.     Protected with internal locks.
  125.     Must get data_lock when resetting the logs.
  126.   */
  127.   MYSQL_LOG relay_log;
  128.   LOG_INFO linfo;
  129.   IO_CACHE cache_buf,*cur_log;
  130.   /* The following variables are safe to read any time */
  131.   /* IO_CACHE of the info file - set only during init or end */
  132.   IO_CACHE info_file;
  133.   /*
  134.     When we restart slave thread we need to have access to the previously
  135.     created temporary tables. Modified only on init/end and by the SQL
  136.     thread, read only by SQL thread.
  137.   */
  138.   TABLE *save_temporary_tables;
  139.   /*
  140.     standard lock acquistion order to avoid deadlocks:
  141.     run_lock, data_lock, relay_log.LOCK_log, relay_log.LOCK_index
  142.   */
  143.   pthread_mutex_t data_lock,run_lock;
  144.   /*
  145.     start_cond is broadcast when SQL thread is started
  146.     stop_cond - when stopped
  147.     data_cond - when data protected by data_lock changes
  148.   */
  149.   pthread_cond_t start_cond, stop_cond, data_cond;
  150.   /* parent master info structure */
  151.   struct st_master_info *mi;
  152.   /*
  153.     Needed to deal properly with cur_log getting closed and re-opened with
  154.     a different log under our feet
  155.   */
  156.   uint32 cur_log_old_open_count;
  157.   
  158.   /*
  159.     Let's call a group (of events) :
  160.       - a transaction
  161.       or
  162.       - an autocommiting query + its associated events (INSERT_ID,
  163.     TIMESTAMP...)
  164.     We need these rli coordinates :
  165.     - relay log name and position of the beginning of the group we currently are
  166.     executing. Needed to know where we have to restart when replication has
  167.     stopped in the middle of a group (which has been rolled back by the slave).
  168.     - relay log name and position just after the event we have just
  169.     executed. This event is part of the current group.
  170.     Formerly we only had the immediately above coordinates, plus a 'pending'
  171.     variable, but this dealt wrong with the case of a transaction starting on a
  172.     relay log and finishing (commiting) on another relay log. Case which can
  173.     happen when, for example, the relay log gets rotated because of
  174.     max_binlog_size.
  175.   */
  176.   char group_relay_log_name[FN_REFLEN];
  177.   ulonglong group_relay_log_pos;
  178.   char event_relay_log_name[FN_REFLEN];
  179.   ulonglong event_relay_log_pos;
  180.   /* 
  181.      Original log name and position of the group we're currently executing
  182.      (whose coordinates are group_relay_log_name/pos in the relay log)
  183.      in the master's binlog. These concern the *group*, because in the master's
  184.      binlog the log_pos that comes with each event is the position of the
  185.      beginning of the group.
  186.   */
  187.   char group_master_log_name[FN_REFLEN];
  188.   volatile my_off_t group_master_log_pos;
  189.   /*
  190.     Handling of the relay_log_space_limit optional constraint.
  191.     ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
  192.     threads, the SQL thread sets it to unblock the I/O thread and make it
  193.     temporarily forget about the constraint.
  194.   */
  195.   ulonglong log_space_limit,log_space_total;
  196.   bool ignore_log_space_limit;
  197.   /*
  198.     When it commits, InnoDB internally stores the master log position it has
  199.     processed so far; the position to store is the one of the end of the
  200.     committing event (the COMMIT query event, or the event if in autocommit
  201.     mode).
  202.   */
  203. #if MYSQL_VERSION_ID < 40100
  204.   ulonglong future_master_log_pos;
  205. #else
  206.   ulonglong future_group_master_log_pos;
  207. #endif
  208.   time_t last_master_timestamp; 
  209.   /*
  210.     Needed for problems when slave stops and we want to restart it
  211.     skipping one or more events in the master log that have caused
  212.     errors, and have been manually applied by DBA already.
  213.   */
  214.   volatile uint32 slave_skip_counter;
  215.   volatile ulong abort_pos_wait; /* Incremented on change master */
  216.   volatile ulong slave_run_id; /* Incremented on slave start */
  217.   pthread_mutex_t log_space_lock;
  218.   pthread_cond_t log_space_cond;
  219.   THD * sql_thd;
  220.   int last_slave_errno;
  221. #ifndef DBUG_OFF
  222.   int events_till_abort;
  223. #endif  
  224.   char last_slave_error[MAX_SLAVE_ERRMSG];
  225.   /* if not set, the value of other members of the structure are undefined */
  226.   bool inited;
  227.   volatile bool abort_slave;
  228.   volatile uint slave_running;
  229.   /* 
  230.      Condition and its parameters from START SLAVE UNTIL clause.
  231.      
  232.      UNTIL condition is tested with is_until_satisfied() method that is 
  233.      called by exec_relay_log_event(). is_until_satisfied() caches the result
  234.      of the comparison of log names because log names don't change very often;
  235.      this cache is invalidated by parts of code which change log names with
  236.      notify_*_log_name_updated() methods. (They need to be called only if SQL
  237.      thread is running).
  238.    */
  239.   
  240.   enum {UNTIL_NONE= 0, UNTIL_MASTER_POS, UNTIL_RELAY_POS} until_condition;
  241.   char until_log_name[FN_REFLEN];
  242.   ulonglong until_log_pos;
  243.   /* extension extracted from log_name and converted to int */
  244.   ulong until_log_name_extension;   
  245.   /* 
  246.      Cached result of comparison of until_log_name and current log name
  247.      -2 means unitialised, -1,0,1 are comarison results 
  248.   */
  249.   enum 
  250.   { 
  251.     UNTIL_LOG_NAMES_CMP_UNKNOWN= -2, UNTIL_LOG_NAMES_CMP_LESS= -1,
  252.     UNTIL_LOG_NAMES_CMP_EQUAL= 0, UNTIL_LOG_NAMES_CMP_GREATER= 1
  253.   } until_log_names_cmp_result;
  254.   /*
  255.     trans_retries varies between 0 to slave_transaction_retries and counts how
  256.     many times the slave has retried the present transaction; gets reset to 0
  257.     when the transaction finally succeeds. retried_trans is a cumulative
  258.     counter: how many times the slave has retried a transaction (any) since
  259.     slave started.
  260.   */
  261.   ulong trans_retries, retried_trans;
  262.   /*
  263.     If the end of the hot relay log is made of master's events ignored by the
  264.     slave I/O thread, these two keep track of the coords (in the master's
  265.     binlog) of the last of these events seen by the slave I/O thread. If not,
  266.     ign_master_log_name_end[0] == 0.
  267.     As they are like a Rotate event read/written from/to the relay log, they
  268.     are both protected by rli->relay_log.LOCK_log.
  269.   */
  270.   char ign_master_log_name_end[FN_REFLEN];
  271.   ulonglong ign_master_log_pos_end;
  272.   st_relay_log_info();
  273.   ~st_relay_log_info();
  274.   /*
  275.     Invalidate cached until_log_name and group_relay_log_name comparison 
  276.     result. Should be called after any update of group_realy_log_name if
  277.     there chances that sql_thread is running.
  278.   */
  279.   inline void notify_group_relay_log_name_update()
  280.   {
  281.     if (until_condition==UNTIL_RELAY_POS)
  282.       until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
  283.   }
  284.   /*
  285.     The same as previous but for group_master_log_name. 
  286.   */
  287.   inline void notify_group_master_log_name_update()
  288.   {
  289.     if (until_condition==UNTIL_MASTER_POS)
  290.       until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
  291.   }
  292.   
  293.   inline void inc_event_relay_log_pos(ulonglong val)
  294.   {
  295.     event_relay_log_pos+= val;
  296.   }
  297.   void inc_group_relay_log_pos(ulonglong val, ulonglong log_pos, bool skip_lock=0);
  298.   int wait_for_pos(THD* thd, String* log_name, longlong log_pos, 
  299.    longlong timeout);
  300.   void close_temporary_tables();
  301.   /* Check if UNTIL condition is satisfied. See slave.cc for more. */
  302.   bool is_until_satisfied();
  303.   inline ulonglong until_pos()
  304.   {
  305.     return ((until_condition == UNTIL_MASTER_POS) ? group_master_log_pos :
  306.     group_relay_log_pos);
  307.   }
  308. } RELAY_LOG_INFO;
  309. Log_event* next_event(RELAY_LOG_INFO* rli);
  310. /*****************************************************************************
  311.   Replication IO Thread
  312.   st_master_info contains:
  313.     - information about how to connect to a master
  314.     - current master log name
  315.     - current master log offset
  316.     - misc control variables
  317.   st_master_info is initialized once from the master.info file if such
  318.   exists. Otherwise, data members corresponding to master.info fields
  319.   are initialized with defaults specified by master-* options. The
  320.   initialization is done through init_master_info() call.
  321.   The format of master.info file:
  322.   log_name
  323.   log_pos
  324.   master_host
  325.   master_user
  326.   master_pass
  327.   master_port
  328.   master_connect_retry
  329.   To write out the contents of master.info file to disk ( needed every
  330.   time we read and queue data from the master ), a call to
  331.   flush_master_info() is required.
  332.   To clean up, call end_master_info()
  333. *****************************************************************************/
  334. typedef struct st_master_info
  335. {
  336.   /* the variables below are needed because we can change masters on the fly */
  337.   char master_log_name[FN_REFLEN];
  338.   char host[HOSTNAME_LENGTH+1];
  339.   char user[USERNAME_LENGTH+1];
  340.   char password[MAX_PASSWORD_LENGTH+1];
  341.   my_bool ssl; // enables use of SSL connection if true
  342.   char ssl_ca[FN_REFLEN], ssl_capath[FN_REFLEN], ssl_cert[FN_REFLEN];
  343.   char ssl_cipher[FN_REFLEN], ssl_key[FN_REFLEN];
  344.   
  345.   my_off_t master_log_pos;
  346.   File fd; // we keep the file open, so we need to remember the file pointer
  347.   IO_CACHE file;
  348.   
  349.   pthread_mutex_t data_lock,run_lock;
  350.   pthread_cond_t data_cond,start_cond,stop_cond;
  351.   THD *io_thd;
  352.   MYSQL* mysql;
  353.   uint32 file_id; /* for 3.23 load data infile */
  354.   RELAY_LOG_INFO rli;
  355.   uint port;
  356.   uint connect_retry;
  357. #ifndef DBUG_OFF
  358.   int events_till_abort;
  359. #endif
  360.   bool inited;
  361.   enum enum_binlog_formats old_format;
  362.   volatile bool abort_slave;
  363.   volatile uint slave_running;
  364.   volatile ulong slave_run_id;
  365.   /* 
  366.      The difference in seconds between the clock of the master and the clock of
  367.      the slave (second - first). It must be signed as it may be <0 or >0.
  368.      clock_diff_with_master is computed when the I/O thread starts; for this the
  369.      I/O thread does a SELECT UNIX_TIMESTAMP() on the master.
  370.      "how late the slave is compared to the master" is computed like this:
  371.      clock_of_slave - last_timestamp_executed_by_SQL_thread - clock_diff_with_master
  372.   */
  373.   long clock_diff_with_master; 
  374.   
  375.   st_master_info()
  376.     :ssl(0), fd(-1),  io_thd(0), inited(0), old_format(BINLOG_FORMAT_CURRENT),
  377.      abort_slave(0),slave_running(0), slave_run_id(0)
  378.   {
  379.     host[0] = 0; user[0] = 0; password[0] = 0;
  380.     ssl_ca[0]= 0; ssl_capath[0]= 0; ssl_cert[0]= 0;
  381.     ssl_cipher[0]= 0; ssl_key[0]= 0;
  382.     
  383.     bzero((char*) &file, sizeof(file));
  384.     pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
  385.     pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
  386.     pthread_cond_init(&data_cond, NULL);
  387.     pthread_cond_init(&start_cond, NULL);
  388.     pthread_cond_init(&stop_cond, NULL);
  389.   }
  390.   ~st_master_info()
  391.   {
  392.     pthread_mutex_destroy(&run_lock);
  393.     pthread_mutex_destroy(&data_lock);
  394.     pthread_cond_destroy(&data_cond);
  395.     pthread_cond_destroy(&start_cond);
  396.     pthread_cond_destroy(&stop_cond);
  397.   }
  398. } MASTER_INFO;
  399. int queue_event(MASTER_INFO* mi,const char* buf,ulong event_len);
  400. typedef struct st_table_rule_ent
  401. {
  402.   char* db;
  403.   char* tbl_name;
  404.   uint key_len;
  405. } TABLE_RULE_ENT;
  406. #define TABLE_RULE_HASH_SIZE   16
  407. #define TABLE_RULE_ARR_SIZE   16
  408. #define MAX_SLAVE_ERRMSG      1024
  409. #define RPL_LOG_NAME (rli->group_master_log_name[0] ? rli->group_master_log_name :
  410.  "FIRST")
  411. #define IO_RPL_LOG_NAME (mi->master_log_name[0] ? mi->master_log_name :
  412.  "FIRST")
  413. /* masks for start/stop operations on io and sql slave threads */
  414. #define SLAVE_IO  1
  415. #define SLAVE_SQL 2
  416. /*
  417.   If the following is set, if first gives an error, second will be
  418.   tried. Otherwise, if first fails, we fail.
  419. */
  420. #define SLAVE_FORCE_ALL 4
  421. int init_slave();
  422. void init_slave_skip_errors(const char* arg);
  423. bool flush_master_info(MASTER_INFO* mi, bool flush_relay_log_cache);
  424. bool flush_relay_log_info(RELAY_LOG_INFO* rli);
  425. int register_slave_on_master(MYSQL* mysql);
  426. int terminate_slave_threads(MASTER_INFO* mi, int thread_mask,
  427.      bool skip_lock = 0);
  428. int terminate_slave_thread(THD* thd, pthread_mutex_t* term_mutex,
  429.    pthread_mutex_t* cond_lock,
  430.    pthread_cond_t* term_cond,
  431.    volatile uint* slave_running);
  432. int start_slave_threads(bool need_slave_mutex, bool wait_for_start,
  433. MASTER_INFO* mi, const char* master_info_fname,
  434. const char* slave_info_fname, int thread_mask);
  435. /*
  436.   cond_lock is usually same as start_lock. It is needed for the case when
  437.   start_lock is 0 which happens if start_slave_thread() is called already
  438.   inside the start_lock section, but at the same time we want a
  439.   pthread_cond_wait() on start_cond,start_lock
  440. */
  441. int start_slave_thread(pthread_handler h_func, pthread_mutex_t* start_lock,
  442.        pthread_mutex_t *cond_lock,
  443.        pthread_cond_t* start_cond,
  444.        volatile uint *slave_running,
  445.        volatile ulong *slave_run_id,
  446.        MASTER_INFO* mi,
  447.                        bool high_priority);
  448. /* If fd is -1, dump to NET */
  449. int mysql_table_dump(THD* thd, const char* db,
  450.      const char* tbl_name, int fd = -1);
  451. /* retrieve table from master and copy to slave*/
  452. int fetch_master_table(THD* thd, const char* db_name, const char* table_name,
  453.        MASTER_INFO* mi, MYSQL* mysql, bool overwrite);
  454. void table_rule_ent_hash_to_str(String* s, HASH* h);
  455. void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a);
  456. int show_master_info(THD* thd, MASTER_INFO* mi);
  457. int show_binlog_info(THD* thd);
  458. /* See if the query uses any tables that should not be replicated */
  459. bool tables_ok(THD* thd, TABLE_LIST* tables);
  460. /*
  461.   Check to see if the database is ok to operate on with respect to the
  462.   do and ignore lists - used in replication
  463. */
  464. int db_ok(const char* db, I_List<i_string> &do_list,
  465.   I_List<i_string> &ignore_list );
  466. int db_ok_with_wild_table(const char *db);
  467. int add_table_rule(HASH* h, const char* table_spec);
  468. int add_wild_table_rule(DYNAMIC_ARRAY* a, const char* table_spec);
  469. void init_table_rule_hash(HASH* h, bool* h_inited);
  470. void init_table_rule_array(DYNAMIC_ARRAY* a, bool* a_inited);
  471. const char *rewrite_db(const char* db, uint32 *new_db_len);
  472. const char *print_slave_db_safe(const char *db);
  473. int check_expected_error(THD* thd, RELAY_LOG_INFO* rli, int error_code);
  474. void skip_load_data_infile(NET* net);
  475. void slave_print_error(RELAY_LOG_INFO* rli, int err_code, const char* msg, ...);
  476. void end_slave(); /* clean up */
  477. void init_master_info_with_options(MASTER_INFO* mi);
  478. void clear_until_condition(RELAY_LOG_INFO* rli);
  479. void clear_slave_error(RELAY_LOG_INFO* rli);
  480. int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
  481.      const char* slave_info_fname,
  482.      bool abort_if_no_master_info_file,
  483.      int thread_mask);
  484. void end_master_info(MASTER_INFO* mi);
  485. int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname);
  486. void end_relay_log_info(RELAY_LOG_INFO* rli);
  487. void lock_slave_threads(MASTER_INFO* mi);
  488. void unlock_slave_threads(MASTER_INFO* mi);
  489. void init_thread_mask(int* mask,MASTER_INFO* mi,bool inverse);
  490. int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,ulonglong pos,
  491.        bool need_data_lock, const char** errmsg);
  492. int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
  493.      const char** errmsg);
  494. void rotate_relay_log(MASTER_INFO* mi);
  495. extern "C" pthread_handler_decl(handle_slave_io,arg);
  496. extern "C" pthread_handler_decl(handle_slave_sql,arg);
  497. extern bool volatile abort_loop;
  498. extern MASTER_INFO main_mi, *active_mi; /* active_mi for multi-master */
  499. extern LIST master_list;
  500. extern HASH replicate_do_table, replicate_ignore_table;
  501. extern DYNAMIC_ARRAY  replicate_wild_do_table, replicate_wild_ignore_table;
  502. extern bool do_table_inited, ignore_table_inited,
  503.     wild_do_table_inited, wild_ignore_table_inited;
  504. extern bool table_rules_on, replicate_same_server_id;
  505. extern int disconnect_slave_event_count, abort_slave_event_count ;
  506. /* the master variables are defaults read from my.cnf or command line */
  507. extern uint master_port, master_connect_retry, report_port;
  508. extern my_string master_user, master_password, master_host,
  509.        master_info_file, relay_log_info_file, report_user, report_host,
  510.        report_password;
  511. extern my_bool master_ssl;
  512. extern my_string master_ssl_ca, master_ssl_capath, master_ssl_cert,
  513.        master_ssl_cipher, master_ssl_key;
  514.        
  515. extern I_List<i_string> replicate_do_db, replicate_ignore_db;
  516. extern I_List<i_string_pair> replicate_rewrite_db;
  517. extern I_List<THD> threads;
  518. #endif
  519. #else
  520. #define SLAVE_IO  1
  521. #define SLAVE_SQL 2
  522. #endif /* HAVE_REPLICATION */