Merge lp:~linuxjedi/libdrizzle/5.1-binlog-callback into lp:libdrizzle

[Andrew Hutchings]

=== modified file 'libdrizzle-5.1/binlog.h'
--- libdrizzle-5.1/binlog.h	2013-01-13 22:31:54 +0000
+++ libdrizzle-5.1/binlog.h	2013-01-27 05:24:24 +0000
@@ -42,45 +42,52 @@
 #endif
 
 DRIZZLE_API
-drizzle_result_st *drizzle_start_binlog(drizzle_st *con,
+drizzle_binlog_st *drizzle_binlog_init(drizzle_st *con,
+                                       drizzle_binlog_fn *binlog_fn,
+                                       drizzle_binlog_error_fn *error_fn,
+                                       void *context,
+                                       bool verify_checksums);
+
+
+DRIZZLE_API
+void drizzle_binlog_free(drizzle_binlog_st *binlog);
+
+DRIZZLE_API
+drizzle_return_t drizzle_binlog_start(drizzle_binlog_st *binlog,
                                         uint32_t server_id,
                                         const char *file,
-                                        uint32_t start_position,
-                                        bool verify_checksums,
-                                        drizzle_return_t *ret_ptr);
-
-DRIZZLE_API
-drizzle_return_t drizzle_binlog_get_next_event(drizzle_result_st *result);
-
-DRIZZLE_API
-uint32_t drizzle_binlog_event_timestamp(drizzle_result_st *result);
-
-DRIZZLE_API
-drizzle_binlog_event_types_t drizzle_binlog_event_type(drizzle_result_st *result);
-
-DRIZZLE_API
-uint32_t drizzle_binlog_event_server_id(drizzle_result_st *result);
-
-DRIZZLE_API
-uint32_t drizzle_binlog_event_length(drizzle_result_st *result);
-
-DRIZZLE_API
-uint32_t drizzle_binlog_event_next_pos(drizzle_result_st *result);
-
-DRIZZLE_API
-uint16_t drizzle_binlog_event_flags(drizzle_result_st *result);
-
-DRIZZLE_API
-uint16_t drizzle_binlog_event_extra_flags(drizzle_result_st *result);
-
-DRIZZLE_API
-const unsigned char *drizzle_binlog_event_data(drizzle_result_st *result);
-
-DRIZZLE_API
-const unsigned char *drizzle_binlog_event_raw_data(drizzle_result_st *result);
-
-DRIZZLE_API
-uint32_t drizzle_binlog_event_raw_length(drizzle_result_st *result);
+                                        uint32_t start_position);
+
+
+DRIZZLE_API
+uint32_t drizzle_binlog_event_timestamp(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+drizzle_binlog_event_types_t drizzle_binlog_event_type(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+uint32_t drizzle_binlog_event_server_id(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+uint32_t drizzle_binlog_event_length(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+uint32_t drizzle_binlog_event_next_pos(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+uint16_t drizzle_binlog_event_flags(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+uint16_t drizzle_binlog_event_extra_flags(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+const unsigned char *drizzle_binlog_event_data(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+const unsigned char *drizzle_binlog_event_raw_data(drizzle_binlog_event_st *event);
+
+DRIZZLE_API
+uint32_t drizzle_binlog_event_raw_length(drizzle_binlog_event_st *event);
 
 #ifdef __cplusplus
 }

=== modified file 'libdrizzle-5.1/constants.h'
--- libdrizzle-5.1/constants.h	2013-01-26 23:09:08 +0000
+++ libdrizzle-5.1/constants.h	2013-01-27 05:24:24 +0000
@@ -564,6 +564,7 @@
 typedef struct drizzle_result_st drizzle_result_st;
 typedef struct drizzle_column_st drizzle_column_st;
 typedef struct drizzle_binlog_st drizzle_binlog_st;
+typedef struct drizzle_binlog_event_st drizzle_binlog_event_st;
 typedef struct drizzle_stmt_st drizzle_stmt_st;
 typedef struct drizzle_bind_st drizzle_bind_st;
 typedef char *drizzle_field_t;
@@ -571,6 +572,8 @@
 
 typedef void (drizzle_log_fn)(const char *line, drizzle_verbose_t verbose,
                               void *context);
+typedef void (drizzle_binlog_fn)(drizzle_binlog_event_st *event, void *context);
+typedef void (drizzle_binlog_error_fn)(drizzle_return_t error, void *context);
 typedef drizzle_return_t (drizzle_state_fn)(drizzle_st *con);
 typedef void (drizzle_context_free_fn)(drizzle_st *con,
                                            void *context);

=== modified file 'libdrizzle/binlog.cc'
--- libdrizzle/binlog.cc	2013-01-27 04:54:08 +0000
+++ libdrizzle/binlog.cc	2013-01-27 05:24:24 +0000
@@ -40,24 +40,62 @@
 
 #include <zlib.h>
 
-drizzle_result_st *drizzle_start_binlog(drizzle_st *con,
-                                            uint32_t server_id,
-                                            const char *file,
-                                            uint32_t start_position,
-                                            bool verify_checksums,
-                                            drizzle_return_t *ret_ptr)
+drizzle_binlog_st *drizzle_binlog_init(drizzle_st *con,
+                                       drizzle_binlog_fn *binlog_fn,
+                                       drizzle_binlog_error_fn *error_fn,
+                                       void *context,
+                                       bool verify_checksums)
+{
+  if (con == NULL)
+  {
+    return NULL;
+  }
+
+  drizzle_binlog_st *binlog= new (std::nothrow) drizzle_binlog_st;
+  if (binlog == NULL)
+  {
+    drizzle_set_error(con, __func__, "error allocating binlog struct");
+    return NULL;
+  }
+  binlog->con= con;
+  binlog->binlog_fn= binlog_fn;
+  binlog->error_fn= error_fn;
+  binlog->binlog_context= context;
+  binlog->verify_checksums= verify_checksums;
+
+  return binlog;
+}
+
+void drizzle_binlog_free(drizzle_binlog_st *binlog)
+{
+  delete binlog;
+}
+
+drizzle_return_t drizzle_binlog_start(drizzle_binlog_st *binlog,
+                                          uint32_t server_id,
+                                          const char *file,
+                                          uint32_t start_position)
 { 
   unsigned char data[128];
   unsigned char *ptr;
   uint8_t len= 0, fn_len= 0;
   drizzle_result_st *result;
+  drizzle_st *con;
+  drizzle_return_t ret;
+
+  if (binlog == NULL)
+  {
+    return DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+
+  con= binlog->con;
 
   // Hack in 5.6 to say that client support checksums
-  result= drizzle_query(con, "SET @master_binlog_checksum='NONE'", 0, ret_ptr);
+  result= drizzle_query(con, "SET @master_binlog_checksum='NONE'", 0, &ret);
   drizzle_result_free(result);
-  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  if (ret != DRIZZLE_RETURN_OK)
   {
-    return NULL;
+    return ret;
   }
 
   ptr= data;
@@ -96,135 +134,128 @@
   }
 
   result= drizzle_command_write(con, NULL, DRIZZLE_COMMAND_BINLOG_DUMP,
-                                   data, len, len, ret_ptr);
-  result->binlog_event= new (std::nothrow) drizzle_binlog_st;
-  result->binlog_event->verify_checksums= verify_checksums;
-  return result;
-}
+                                   data, len, len, &ret);
 
-drizzle_return_t drizzle_binlog_get_next_event(drizzle_result_st *result)
-{
-  if (result == NULL)
+  con->binlog= binlog;
+  if (ret != DRIZZLE_RETURN_OK)
   {
-    return DRIZZLE_RETURN_INVALID_ARGUMENT;
+    return ret;
   }
-
   result->push_state(drizzle_state_binlog_read);
   result->push_state(drizzle_state_packet_read);
-
-  return drizzle_state_loop(result->con);
+  return drizzle_state_loop(con);
 }
 
-uint32_t drizzle_binlog_event_timestamp(drizzle_result_st *result)
+uint32_t drizzle_binlog_event_timestamp(drizzle_binlog_event_st *event)
 {
-  if ((result == NULL) || (result->binlog_event == NULL))
+  if (event == NULL)
   {
     return 0;
   }
 
-  return result->binlog_event->timestamp;
+  return event->timestamp;
 }
 
-drizzle_binlog_event_types_t drizzle_binlog_event_type(drizzle_result_st *result)
+drizzle_binlog_event_types_t drizzle_binlog_event_type(drizzle_binlog_event_st *event)
 {
-  if ((result == NULL) || (result->binlog_event == NULL))
+  if (event == NULL)
   {
     return drizzle_binlog_event_types_t();
   }
 
-  return result->binlog_event->type;
-}
-
-uint32_t drizzle_binlog_event_server_id(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return 0;
-  }
-
-  return result->binlog_event->server_id;
-}
-
-uint32_t drizzle_binlog_event_length(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return 0;
-  }
-
-  return result->binlog_event->length;
-}
-
-uint32_t drizzle_binlog_event_next_pos(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return 0;
-  }
-
-  return result->binlog_event->next_pos;
-}
-
-uint16_t drizzle_binlog_event_flags(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return 0;
-  }
-
-  return result->binlog_event->flags;
-}
-
-uint16_t drizzle_binlog_event_extra_flags(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return 0;
-  }
-
-  return result->binlog_event->extra_flags;
-}
-
-const unsigned char *drizzle_binlog_event_data(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return NULL;
-  }
-
-  return result->binlog_event->data;
-}
-
-const unsigned char *drizzle_binlog_event_raw_data(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return NULL;
-  }
-
-  return result->binlog_event->raw_data;
-}
-
-uint32_t drizzle_binlog_event_raw_length(drizzle_result_st *result)
-{
-  if ((result == NULL) || (result->binlog_event == NULL))
-  {
-    return 0;
-  }
-
-  return result->binlog_event->raw_length;
+  return event->type;
+}
+
+uint32_t drizzle_binlog_event_server_id(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return 0;
+  }
+
+  return event->server_id;
+}
+
+uint32_t drizzle_binlog_event_length(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return 0;
+  }
+
+  return event->length;
+}
+
+uint32_t drizzle_binlog_event_next_pos(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return 0;
+  }
+
+  return event->next_pos;
+}
+
+uint16_t drizzle_binlog_event_flags(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return 0;
+  }
+
+  return event->flags;
+}
+
+uint16_t drizzle_binlog_event_extra_flags(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return 0;
+  }
+
+  return event->extra_flags;
+}
+
+const unsigned char *drizzle_binlog_event_data(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return NULL;
+  }
+
+  return event->data;
+}
+
+const unsigned char *drizzle_binlog_event_raw_data(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return NULL;
+  }
+
+  return event->raw_data;
+}
+
+uint32_t drizzle_binlog_event_raw_length(drizzle_binlog_event_st *event)
+{
+  if (event == NULL)
+  {
+    return 0;
+  }
+
+  return event->raw_length;
 }
 
 drizzle_return_t drizzle_state_binlog_read(drizzle_st *con)
 {
-  drizzle_binlog_st *binlog_event;
+  drizzle_binlog_event_st *binlog_event;
 
   if (con == NULL)
   {
     return DRIZZLE_RETURN_INVALID_ARGUMENT;
   }
 
-  binlog_event= con->result->binlog_event;
+  binlog_event= &con->binlog->event;
 
   if (con->packet_size != 0 && con->buffer_size < con->packet_size)
   {
@@ -240,6 +271,7 @@
     con->buffer_ptr+= 5;
     con->buffer_size-= 5;
     con->pop_state();
+    con->binlog->error_fn(DRIZZLE_RETURN_EOF, con->binlog->binlog_context);
     return DRIZZLE_RETURN_EOF;
   }
   else if (con->buffer_ptr[0] == 255)
@@ -267,6 +299,7 @@
     con->packet_size= 0;
 
     con->pop_state();
+    con->binlog->error_fn(DRIZZLE_RETURN_ERROR_CODE, con->binlog->binlog_context);
     return DRIZZLE_RETURN_ERROR_CODE;
   }
   else
@@ -283,6 +316,7 @@
     {
         drizzle_set_error(con, "drizzle_state_binlog_read",
                           "packet size error:%zu:%zu", con->packet_size, binlog_event->length);
+        con->binlog->error_fn(DRIZZLE_RETURN_UNEXPECTED_DATA, con->binlog->binlog_context);
         return DRIZZLE_RETURN_UNEXPECTED_DATA;
     }
     if (binlog_event->length <= 27)
@@ -311,7 +345,7 @@
       {
         if (strncmp((const char*)con->buffer_ptr + 2, DRIZZLE_BINLOG_CHECKSUM_VERSION, strlen(DRIZZLE_BINLOG_CHECKSUM_VERSION)) <= 0)
         {
-          con->result->binlog_checksums= true;
+          con->binlog->has_checksums= true;
         }
       }
       /* A checksum is basically a CRC32 at the end of the event data (4 bytes) */
@@ -320,7 +354,7 @@
       con->buffer_size-= binlog_event->length;
       con->packet_size-= binlog_event->length;
       /* Remove the CRC32 from the event length */
-      if (con->result->binlog_checksums)
+      if (con->binlog->has_checksums)
       {
         binlog_event->length-= DRIZZLE_BINLOG_CRC32_LEN;
       }
@@ -330,16 +364,17 @@
      * each event is checksummed individually, the checksum is the last 4 bytes
      * of the binary log event
      * */
-    if (con->result->binlog_checksums)
+    if (con->binlog->has_checksums)
     {
       uint32_t event_crc;
       memcpy(&binlog_event->checksum, binlog_event->raw_data + (binlog_event->raw_length - DRIZZLE_BINLOG_CRC32_LEN), DRIZZLE_BINLOG_CRC32_LEN);
-      if (binlog_event->verify_checksums)
+      if (con->binlog->verify_checksums)
       {
         event_crc= crc32(0, binlog_event->raw_data, (binlog_event->raw_length - DRIZZLE_BINLOG_CRC32_LEN));
         if (event_crc != binlog_event->checksum)
         {
           drizzle_set_error(con, __func__, "CRC doesn't match: 0x%lX, 0x%lX", event_crc, binlog_event->checksum);
+          con->binlog->error_fn(DRIZZLE_RETURN_BINLOG_CRC, con->binlog->binlog_context);
           return DRIZZLE_RETURN_BINLOG_CRC;
         }
       }
@@ -349,10 +384,16 @@
     {
       drizzle_set_error(con, "drizzle_state_binlog_read",
                         "unexpected data after packet:%zu", con->buffer_size);
+      con->binlog->error_fn(DRIZZLE_RETURN_UNEXPECTED_DATA, con->binlog->binlog_context);
       return DRIZZLE_RETURN_UNEXPECTED_DATA;
     }
     con->pop_state();
   }
+
+  con->binlog->binlog_fn(&con->binlog->event, con->binlog->binlog_context);
+  con->push_state(drizzle_state_binlog_read);
+  con->push_state(drizzle_state_packet_read);
+
   return DRIZZLE_RETURN_OK;
 }
 

=== modified file 'libdrizzle/drizzle.cc'
--- libdrizzle/drizzle.cc	2013-01-27 00:12:38 +0000
+++ libdrizzle/drizzle.cc	2013-01-27 05:24:24 +0000
@@ -240,6 +240,11 @@
     SSL_CTX_free(con->ssl_context);
 #endif
 
+  if (con->binlog != NULL)
+  {
+    drizzle_binlog_free(con->binlog);
+  }
+
   free(con->buffer);
   delete con;
 }

=== modified file 'libdrizzle/result.cc'
--- libdrizzle/result.cc	2013-01-27 04:54:08 +0000
+++ libdrizzle/result.cc	2013-01-27 05:24:24 +0000
@@ -83,11 +83,6 @@
     return;
   }
 
-  if (result->binlog_event != NULL)
-  {
-    delete result->binlog_event;
-  }
-
   for (column= result->column_list; column != NULL; column= result->column_list)
   {
     drizzle_column_free(column);

=== modified file 'libdrizzle/structs.h'
--- libdrizzle/structs.h	2013-01-27 04:58:03 +0000
+++ libdrizzle/structs.h	2013-01-27 05:24:24 +0000
@@ -252,6 +252,7 @@
   char sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE + 1];
   char last_error[DRIZZLE_MAX_ERROR_SIZE];
   drizzle_stmt_st *stmt;
+  drizzle_binlog_st *binlog;
 private:
   size_t _state_stack_count;
   Packet *_state_stack_list;
@@ -296,6 +297,7 @@
     log_fn(NULL),
     log_context(NULL),
     stmt(NULL),
+    binlog(NULL),
     _state_stack_count(0),
     _state_stack_list(NULL)
   {
@@ -393,8 +395,6 @@
   drizzle_row_t *row_list;
   size_t *field_sizes;
   size_t **field_sizes_list;
-  drizzle_binlog_st *binlog_event;
-  bool binlog_checksums;
   uint8_t **null_bitmap_list;
   uint8_t *null_bitmap;
   uint8_t null_bitmap_length;
@@ -427,8 +427,6 @@
     row_list(NULL),
     field_sizes(NULL),
     field_sizes_list(NULL),
-    binlog_event(NULL),
-    binlog_checksums(false),
     null_bitmap_list(NULL),
     null_bitmap(NULL),
     null_bitmap_length(0),
@@ -459,7 +457,7 @@
   }
 };
 
-struct drizzle_binlog_st
+struct drizzle_binlog_event_st
 {
   uint32_t timestamp;
   drizzle_binlog_event_types_t type;
@@ -472,7 +470,38 @@
   unsigned char *data;
   unsigned char *raw_data;
   uint32_t raw_length;
+  drizzle_binlog_event_st() :
+    timestamp(0),
+    type(DRIZZLE_EVENT_TYPE_UNKNOWN),
+    server_id(0),
+    length(0),
+    next_pos(0),
+    flags(0),
+    extra_flags(0),
+    checksum(0),
+    data(NULL),
+    raw_data(NULL),
+    raw_length(0)
+  { }
+};
+
+struct drizzle_binlog_st
+{
+  drizzle_binlog_fn *binlog_fn;
+  drizzle_binlog_error_fn *error_fn;
+  void *binlog_context;
+  drizzle_binlog_event_st event;
   bool verify_checksums;
+  bool has_checksums;
+  drizzle_st *con;
+  drizzle_binlog_st() :
+    binlog_fn(NULL),
+    error_fn(NULL),
+    binlog_context(NULL),
+    verify_checksums(false),
+    has_checksums(false),
+    con(NULL)
+  { }
 };
 
 /**

=== modified file 'tests/unit/binlog.cc'
--- tests/unit/binlog.cc	2013-01-27 00:09:17 +0000
+++ tests/unit/binlog.cc	2013-01-27 05:24:24 +0000
@@ -45,10 +45,33 @@
 #include <cstdio>
 #include <cstdlib>
 
+void binlog_error(drizzle_return_t ret, void *context)
+{
+  (void) context;
+  ASSERT_EQ_(DRIZZLE_RETURN_EOF, ret, "%s(%s)", drizzle_error(con), drizzle_strerror(ret));
+}
+
+void binlog_event(drizzle_binlog_event_st *event, void *context)
+{
+  (void) context;
+  uint32_t timestamp;
+  timestamp= drizzle_binlog_event_timestamp(event);
+  /* Test to see if timestamp is greater than 2012-01-01 00:00:00, corrupted
+   * timestamps will have weird values that shoud fail this after several
+   * events.  Also rotate event doesn't have a timestamp so need to add 0
+   * to this test */
+  ASSERT_FALSE_(((timestamp < 1325376000) && (timestamp != 0)), "Bad timestamp retrieved: %u", timestamp);
+
+  /* An event higher than the max known is bad, either we don't know about
+   * new events or type is corrupted */
+  ASSERT_FALSE_((drizzle_binlog_event_type(event) >= DRIZZLE_EVENT_TYPE_END), "Bad event type: %d", drizzle_binlog_event_type(event));
+}
+
 int main(int argc, char *argv[])
 {
   (void) argc;
   (void) argv;
+  drizzle_binlog_st *binlog;
 
   con= drizzle_create_tcp(getenv("MYSQL_SERVER"),
                           getenv("MYSQL_PORT") ? atoi("MYSQL_PORT") : DRIZZLE_DEFAULT_TCP_PORT,
@@ -62,32 +85,9 @@
   drizzle_return_t ret= drizzle_connect(con);
   SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", drizzle_error(con), drizzle_strerror(ret));
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s(%s)", drizzle_error(con), drizzle_strerror(ret));
-
-  drizzle_result_st *result= drizzle_start_binlog(con, 0, "", 0, true, &ret);
-  ASSERT_TRUE(result);
+  binlog= drizzle_binlog_init(con, binlog_event, binlog_error, NULL, true);
+  ret= drizzle_binlog_start(binlog, 0, "", 0);
   SKIP_IF_(ret == DRIZZLE_RETURN_ERROR_CODE, "Binlog is not open?: %s(%s)", drizzle_error(con), drizzle_strerror(ret));
-  ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "Drizzle binlog start failure: %s(%s)", drizzle_error(con), drizzle_strerror(ret));
-
-  while (ret == DRIZZLE_RETURN_OK)
-  {
-    uint32_t timestamp;
-    ret= drizzle_binlog_get_next_event(result);
-    if (ret == DRIZZLE_RETURN_EOF)
-    {
-      break;
-    }
-    ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "Binlog error %s\n", drizzle_error(con));
-    timestamp= drizzle_binlog_event_timestamp(result);
-    /* Test to see if timestamp is greater than 2012-01-01 00:00:00, corrupted
-     * timestamps will have weird values that shoud fail this after several
-     * events.  Also rotate event doesn't have a timestamp so need to add 0
-     * to this test */
-    ASSERT_FALSE_(((timestamp < 1325376000) && (timestamp != 0)), "Bad timestamp retrieved: %u", timestamp);
-
-    /* An event higher than the max known is bad, either we don't know about
-     * new events or type is corrupted */
-    ASSERT_FALSE_((drizzle_binlog_event_type(result) >= DRIZZLE_EVENT_TYPE_END), "Bad event type: %d", drizzle_binlog_event_type(result));
-  }
-
+  ASSERT_EQ_(DRIZZLE_RETURN_EOF, ret, "Drizzle binlog start failure: %s(%s)", drizzle_error(con), drizzle_strerror(ret));
   return EXIT_SUCCESS;
 }