replication.h

/* Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.

   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,
   51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */

#ifndef REPLICATION_H
#define REPLICATION_H

#include <mysql.h>

typedef struct st_mysql MYSQL;

#ifdef __cplusplus
extern "C" {
#endif

enum Trans_flags {
  TRANS_IS_REAL_TRANS = 1
};

typedef struct Trans_param {
  uint32 server_id;
  uint32 flags;

  /*
    The latest binary log file name and position written by current
    transaction, if binary log is disabled or no log event has been
    written into binary log file by current transaction (events
    written into transaction log cache are not counted), these two
    member will be zero.
  */
  const char *log_file;
  my_off_t log_pos;
} Trans_param;

typedef struct Trans_observer {
  uint32 len;

  int (*after_commit)(Trans_param *param);

  int (*after_rollback)(Trans_param *param);
} Trans_observer;

enum Binlog_storage_flags {
  BINLOG_STORAGE_IS_SYNCED = 1
};

typedef struct Binlog_storage_param {
  uint32 server_id;
} Binlog_storage_param;

typedef struct Binlog_storage_observer {
  uint32 len;

  int (*after_flush)(Binlog_storage_param *param,
                     const char *log_file, my_off_t log_pos);
} Binlog_storage_observer;

typedef struct Binlog_transmit_param {
  uint32 server_id;
  uint32 flags;
  /* Let us keep 1-16 as output flags and 17-32 as input flags */
  static const uint32 F_OBSERVE= 1;
  static const uint32 F_DONT_OBSERVE= 2;

  void set_observe_flag() { flags|= F_OBSERVE; }
  void set_dont_observe_flag() { flags|= F_DONT_OBSERVE; }
  bool should_observe()
  {
    return (flags & F_OBSERVE) || !(flags & F_DONT_OBSERVE);
  }
} Binlog_transmit_param;

typedef struct Binlog_transmit_observer {
  uint32 len;
  
  int (*transmit_start)(Binlog_transmit_param *param,
                        const char *log_file, my_off_t log_pos);

  int (*transmit_stop)(Binlog_transmit_param *param);

  int (*reserve_header)(Binlog_transmit_param *param,
                        unsigned char *header,
                        unsigned long size,
                        unsigned long *len);

  int (*before_send_event)(Binlog_transmit_param *param,
                           unsigned char *packet, unsigned long len,
                           const char *log_file, my_off_t log_pos );

  int (*after_send_event)(Binlog_transmit_param *param,
                          const char *event_buf, unsigned long len,
                          const char *skipped_log_file, my_off_t skipped_log_pos);

  int (*after_reset_master)(Binlog_transmit_param *param);
} Binlog_transmit_observer;

enum Binlog_relay_IO_flags {
  BINLOG_RELAY_IS_SYNCED = 1
};


typedef struct Binlog_relay_IO_param {
  uint32 server_id;

  /* Master host, user and port */
  char *host;
  char *user;
  unsigned int port;

  char *master_log_name;
  my_off_t master_log_pos;

  MYSQL *mysql;                        /* the connection to master */
} Binlog_relay_IO_param;

typedef struct Binlog_relay_IO_observer {
  uint32 len;

  int (*thread_start)(Binlog_relay_IO_param *param);

  int (*thread_stop)(Binlog_relay_IO_param *param);

  int (*before_request_transmit)(Binlog_relay_IO_param *param, uint32 flags);

  int (*after_read_event)(Binlog_relay_IO_param *param,
                          const char *packet, unsigned long len,
                          const char **event_buf, unsigned long *event_len);

  int (*after_queue_event)(Binlog_relay_IO_param *param,
                           const char *event_buf, unsigned long event_len,
                           uint32 flags);

  int (*after_reset_slave)(Binlog_relay_IO_param *param);
} Binlog_relay_IO_observer;


int register_trans_observer(Trans_observer *observer, void *p);

int unregister_trans_observer(Trans_observer *observer, void *p);

int register_binlog_storage_observer(Binlog_storage_observer *observer, void *p);

int unregister_binlog_storage_observer(Binlog_storage_observer *observer, void *p);

int register_binlog_transmit_observer(Binlog_transmit_observer *observer, void *p);

int unregister_binlog_transmit_observer(Binlog_transmit_observer *observer, void *p);

int register_binlog_relay_io_observer(Binlog_relay_IO_observer *observer, void *p);

int unregister_binlog_relay_io_observer(Binlog_relay_IO_observer *observer, void *p);

void thd_enter_cond(MYSQL_THD thd, mysql_cond_t *cond, mysql_mutex_t *mutex,
                    const PSI_stage_info *stage, PSI_stage_info *old_stage,
                    const char *src_function, const char *src_file,
                    int src_line);

#define THD_ENTER_COND(P1, P2, P3, P4, P5) \
  thd_enter_cond(P1, P2, P3, P4, P5, __func__, __FILE__, __LINE__)

void thd_exit_cond(MYSQL_THD thd, const PSI_stage_info *stage,
                   const char *src_function, const char *src_file,
                   int src_line);

#define THD_EXIT_COND(P1, P2) \
  thd_exit_cond(P1, P2, __func__, __FILE__, __LINE__)

int get_user_var_int(const char *name,
                     long long int *value, int *null_value);

int get_user_var_real(const char *name,
                      double *value, int *null_value);

int get_user_var_str(const char *name,
                     char *value, unsigned long len,
                     unsigned int precision, int *null_value);

  

#ifdef __cplusplus
}
#endif
#endif /* REPLICATION_H */