ruby-binlog 0.1.0

data/README

@@ -0,0 +1,28 @@
+= ruby-binlog
+
+== Description
+
+ruby-binlog is Ruby binding for MySQL Binary log API.
+
+see http://www.oscon.com/oscon2011/public/schedule/detail/18785
+
+== Install
+
+gem install ruby-binlog
+
+== Example
+
+  require "binlog"
+  
+  client = Binlog::Client.new("mysql://repl:repl@nyarlathotep")
+  client.connect
+  client.position = 4
+  
+  while event = client.wait_for_next_event
+    case event
+    when Binlog::QueryEvent
+      puts event.query
+    else
+      puts "(#{event.event_type})"
+    end
+  end

data/ext/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib64/ruby/1.8/x86_64-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr
+exec_prefix = $(DESTDIR)/usr
+vendorarchdir = $(libdir)/ruby/$(ruby_version)/$(sitearch)
+vendordir = $(DESTDIR)/usr/lib/ruby
+sitearchdir = $(libdir)/ruby/site_ruby/$(ruby_version)/$(sitearch)
+localedir = $(datarootdir)/locale
+dvidir = $(docdir)
+datadir = $(DESTDIR)/usr/share
+rubylibdir = $(vendordir)/$(ruby_version)
+bindir = $(DESTDIR)/usr/bin
+sharedstatedir = $(DESTDIR)/var/lib
+libexecdir = $(DESTDIR)/usr/libexec
+vendorlibdir = $(vendordir)/$(ruby_version)
+oldincludedir = $(DESTDIR)/usr/include
+sitedir = $(DESTDIR)/usr/lib/ruby/site_ruby
+mandir = $(DESTDIR)/usr/share/man
+datarootdir = $(prefix)/share
+htmldir = $(docdir)
+pdfdir = $(docdir)
+localstatedir = $(DESTDIR)/var
+includedir = $(DESTDIR)/usr/include
+sitelibdir = $(sitedir)/$(ruby_version)
+sysconfdir = $(DESTDIR)/etc
+psdir = $(docdir)
+libdir = $(DESTDIR)/usr/lib64
+docdir = $(datarootdir)/doc/$(PACKAGE)
+archdir = $(libdir)/ruby/$(ruby_version)/$(sitearch)
+infodir = $(DESTDIR)/usr/share/info
+sbindir = $(DESTDIR)/usr/sbin
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fPIC -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic -fno-strict-aliasing -fno-stack-protector  -fPIC $(cflags) 
+INCFLAGS = -I. -I. -I/usr/lib64/ruby/1.8/x86_64-linux -I.
+DEFS     = 
+CPPFLAGS =    
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L.  -rdynamic -Wl,-export-dynamic
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = $(CC) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = x86_64-linux
+sitearch = x86_64-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED) -lreplication -lstdc++  -lpthread -lrt -ldl -lcrypt -lm   -lc
+SRCS = ruby_binlog_xid_event.cpp ruby_binlog_rotate_event.cpp ruby_binlog_format_event.cpp ruby_binlog_user_var_event.cpp ruby_binlog.cpp ruby_binlog_table_map_event.cpp ruby_binlog_row_event.cpp ruby_binlog_event.cpp ruby_binlog_query_event.cpp ruby_binlog_unimplemented_event.cpp ruby_binlog_int_var_event.cpp ruby_binlog_incident_event.cpp
+OBJS = ruby_binlog_xid_event.o ruby_binlog_rotate_event.o ruby_binlog_format_event.o ruby_binlog_user_var_event.o ruby_binlog.o ruby_binlog_table_map_event.o ruby_binlog_row_event.o ruby_binlog_event.o ruby_binlog_query_event.o ruby_binlog_unimplemented_event.o ruby_binlog_int_var_event.o ruby_binlog_incident_event.o
+TARGET = binlog
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+if have_library('stdc++') and have_library('replication')
+  create_makefile('binlog')
+end

data/ext/mkmf.log

@@ -0,0 +1,24 @@
+have_library: checking for main() in -lstdc++... -------------------- yes
+
+"gcc -o conftest -I. -I/usr/lib64/ruby/1.8/x86_64-linux -I.    -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic -fno-strict-aliasing -fno-stack-protector  -fPIC   conftest.c  -L. -L/usr/lib64 -L.  -rdynamic -Wl,-export-dynamic     -lruby -lstdc++  -lpthread -lrt -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+
+have_library: checking for main() in -lreplication... -------------------- yes
+
+"gcc -o conftest -I. -I/usr/lib64/ruby/1.8/x86_64-linux -I.    -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic -fno-strict-aliasing -fno-stack-protector  -fPIC   conftest.c  -L. -L/usr/lib64 -L.  -rdynamic -Wl,-export-dynamic    -lstdc++  -lruby -lreplication -lstdc++  -lpthread -lrt -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+

data/ext/ruby_binlog.cpp

@@ -0,0 +1,276 @@
+#include "ruby_binlog.h"
+
+extern VALUE rb_cBinlogQueryEvent;
+extern VALUE rb_cBinlogRotateEvent;
+extern VALUE rb_cBinlogFormatEvent;
+extern VALUE rb_cBinlogUserVarEvent;
+extern VALUE rb_cBinlogTableMapEvent;
+extern VALUE rb_cBinlogRowEvent;
+extern VALUE rb_cBinlogIntVarEvent;
+extern VALUE rb_cBinlogIncidentEvent;
+extern VALUE rb_cBinlogXid;
+extern VALUE rb_cBinlogUnimplementedEvent;
+
+namespace ruby {
+namespace binlog {
+
+struct Client {
+  Binary_log *m_binlog;
+
+  static void free(Client *p) {
+    if (p->m_binlog) {
+      delete p->m_binlog;
+      p->m_binlog = 0;
+    }
+
+    delete p;
+  }
+
+  static VALUE alloc(VALUE klass) {
+    Client *p = new Client();
+    return Data_Wrap_Struct(klass, 0, &free, p);
+  }
+
+  static VALUE initialize(VALUE self, VALUE uri) {
+    Client *p;
+
+    Check_Type(uri, T_STRING);
+    Data_Get_Struct(self, Client, p);
+    p->m_binlog = new mysql::Binary_log(
+      mysql::system::create_transport(StringValuePtr(uri)));
+
+    return Qnil;
+  }
+
+  static VALUE connect(VALUE self) {
+    Client *p;
+    int result;
+
+    Data_Get_Struct(self, Client, p);
+    result = p->m_binlog->connect();
+
+    return (result == 0) ? Qtrue : Qfalse;
+  }
+
+  static VALUE wait_for_next_event(VALUE self) {
+    Client *p;
+    Binary_log_event *event;
+    int result;
+    VALUE retval = Qnil;
+
+    Data_Get_Struct(self, Client, p);
+
+    TRAP_BEG;
+    result = p->m_binlog->wait_for_next_event(&event);
+    TRAP_END;
+
+    if (result == ERR_EOF) {
+      return Qfalse;
+    }
+
+    switch (event->get_event_type()) {
+    case QUERY_EVENT:
+      retval = rb_funcall(rb_cBinlogQueryEvent, rb_intern("new"), 0);
+      QueryEvent::set_event(retval, event);
+      break;
+
+    case ROTATE_EVENT:
+      retval = rb_funcall(rb_cBinlogRotateEvent, rb_intern("new"), 0);
+      RotateEvent::set_event(retval, event);
+      break;
+
+    case FORMAT_DESCRIPTION_EVENT: // XXX: Is it right?
+      retval = rb_funcall(rb_cBinlogFormatEvent, rb_intern("new"), 0);
+      FormatEvent::set_event(retval, event);
+      break;
+
+    case USER_VAR_EVENT:
+      retval = rb_funcall(rb_cBinlogUserVarEvent, rb_intern("new"), 0);
+      UserVarEvent::set_event(retval, event);
+      break;
+
+    case TABLE_MAP_EVENT:
+      retval = rb_funcall(rb_cBinlogTableMapEvent, rb_intern("new"), 0);
+      TableMapEvent::set_event(retval, event);
+      break;
+
+    // XXX: Is it right?
+    case PRE_GA_WRITE_ROWS_EVENT:
+    case PRE_GA_UPDATE_ROWS_EVENT:
+    case PRE_GA_DELETE_ROWS_EVENT:
+    case WRITE_ROWS_EVENT: 
+    case UPDATE_ROWS_EVENT:
+    case DELETE_ROWS_EVENT:
+      retval = rb_funcall(rb_cBinlogRowEvent, rb_intern("new"), 0);
+      RowEvent::set_event(retval, event);
+      break;
+
+    case INTVAR_EVENT:
+      retval = rb_funcall(rb_cBinlogIntVarEvent, rb_intern("new"), 0);
+      IntVarEvent::set_event(retval, event);
+      break;
+
+    case INCIDENT_EVENT:
+      retval = rb_funcall(rb_cBinlogIncidentEvent, rb_intern("new"), 0);
+      IncidentEvent::set_event(retval, event);
+      break;
+
+    case XID_EVENT:
+      retval = rb_funcall(rb_cBinlogXid, rb_intern("new"), 0);
+      XidEvent::set_event(retval, event);
+      break;
+
+    default:
+      retval = rb_funcall(rb_cBinlogUnimplementedEvent, rb_intern("new"), 0);
+      UnimplementedEvent::set_event(retval, event);
+      break;
+    }
+
+    return retval;
+  }
+
+  static VALUE set_position(int argc, VALUE *argv, VALUE self) {
+    Client *p;
+    VALUE filename, position, retval = Qnil;
+    int result;
+
+    Data_Get_Struct(self, Client, p);
+    rb_scan_args(argc, argv, "11", &filename, &position);
+
+    if (NIL_P(position)) {
+      unsigned long i_position;
+      i_position = NUM2ULONG(filename);
+      result = p->m_binlog->set_position(i_position);
+    } else {
+      unsigned long i_position;
+      Check_Type(filename, T_STRING);
+      i_position = NUM2ULONG(position);
+      std::string s_filename(StringValuePtr(filename));
+      result = p->m_binlog->set_position(s_filename, i_position);
+    }
+
+    switch (result) {
+    case ERR_OK:
+      retval = Qtrue;
+      break;
+    case ERR_EOF:
+      retval = Qfalse;
+    default:
+      rb_raise(rb_eRuntimeError, "An unspecified error occurred (%d)", result);
+      break;
+    }
+
+    return retval;
+  }
+
+  static VALUE set_position2(VALUE self, VALUE position) {
+    Client *p;
+    VALUE retval = Qnil;
+    int result;
+
+    Data_Get_Struct(self, Client, p);
+    result = p->m_binlog->set_position(NUM2ULONG(position));
+
+    switch (result) {
+    case ERR_OK:
+      retval = Qtrue;
+      break;
+    case ERR_EOF:
+      retval = Qfalse;
+    default:
+      rb_raise(rb_eRuntimeError, "An unspecified error occurred (%d)", result);
+      break;
+    }
+
+    return retval;
+  }
+
+  static VALUE get_position(int argc, VALUE *argv, VALUE self) {
+    Client *p;
+    VALUE filename;
+    unsigned long position;
+
+    Data_Get_Struct(self, Client, p);
+    rb_scan_args(argc, argv, "01", &filename);
+
+    if (NIL_P(filename)) {
+      position = p->m_binlog->get_position();
+    } else {
+      Check_Type(filename, T_STRING);
+      std::string s_filename(StringValuePtr(filename));
+      position = p->m_binlog->get_position(s_filename);
+    }
+
+    return ULONG2NUM(position);
+  }
+
+  static VALUE get_position2(VALUE self) {
+    Client *p;
+    Data_Get_Struct(self, Client, p);
+    return ULONG2NUM(p->m_binlog->get_position());
+  }
+
+  static void init() {
+    VALUE rb_cBinlogClient = rb_define_class_under(rb_mBinlog, "Client", rb_cObject);
+    rb_define_alloc_func(rb_cBinlogClient, &alloc);
+    rb_define_private_method(rb_cBinlogClient, "initialize", __F(&initialize), 1);
+    rb_define_method(rb_cBinlogClient, "connect", __F(&connect), 0);
+    rb_define_method(rb_cBinlogClient, "wait_for_next_event", __F(&wait_for_next_event), 0);
+    rb_define_method(rb_cBinlogClient, "set_position", __F(&set_position), -1);
+    rb_define_method(rb_cBinlogClient, "position=", __F(&set_position2), 1);
+    rb_define_method(rb_cBinlogClient, "get_position", __F(&get_position), -1);
+    rb_define_method(rb_cBinlogClient, "position", __F(&get_position2), 0);
+  }
+};
+
+} // namespace binlog
+} // namespace ruby
+
+VALUE rb_mBinlog;
+VALUE rb_cBinlogEvent;
+
+void Init_binlog() {
+  rb_mBinlog = rb_define_module("Binlog");
+  rb_cBinlogEvent = rb_define_class_under(rb_mBinlog, "Event", rb_cObject);
+
+  rb_define_const(rb_cBinlogEvent, "UNKNOWN_EVENT",            INT2NUM(0));
+  rb_define_const(rb_cBinlogEvent, "START_EVENT_V3",           INT2NUM(1));
+  rb_define_const(rb_cBinlogEvent, "QUERY_EVENT",              INT2NUM(2));
+  rb_define_const(rb_cBinlogEvent, "STOP_EVENT",               INT2NUM(3));
+  rb_define_const(rb_cBinlogEvent, "ROTATE_EVENT",             INT2NUM(4));
+  rb_define_const(rb_cBinlogEvent, "INTVAR_EVENT",             INT2NUM(5));
+  rb_define_const(rb_cBinlogEvent, "LOAD_EVENT",               INT2NUM(6));
+  rb_define_const(rb_cBinlogEvent, "SLAVE_EVENT",              INT2NUM(7));
+  rb_define_const(rb_cBinlogEvent, "CREATE_FILE_EVENT",        INT2NUM(8));
+  rb_define_const(rb_cBinlogEvent, "APPEND_BLOCK_EVENT",       INT2NUM(9));
+  rb_define_const(rb_cBinlogEvent, "EXEC_LOAD_EVENT",          INT2NUM(10));
+  rb_define_const(rb_cBinlogEvent, "DELETE_FILE_EVENT",        INT2NUM(11));
+  rb_define_const(rb_cBinlogEvent, "NEW_LOAD_EVENT",           INT2NUM(12));
+  rb_define_const(rb_cBinlogEvent, "RAND_EVENT",               INT2NUM(13));
+  rb_define_const(rb_cBinlogEvent, "USER_VAR_EVENT",           INT2NUM(14));
+  rb_define_const(rb_cBinlogEvent, "FORMAT_DESCRIPTION_EVENT", INT2NUM(15));
+  rb_define_const(rb_cBinlogEvent, "XID_EVENT",                INT2NUM(16));
+  rb_define_const(rb_cBinlogEvent, "BEGIN_LOAD_QUERY_EVENT",   INT2NUM(17));
+  rb_define_const(rb_cBinlogEvent, "EXECUTE_LOAD_QUERY_EVENT", INT2NUM(18));
+  rb_define_const(rb_cBinlogEvent, "TABLE_MAP_EVENT",          INT2NUM(19));
+  rb_define_const(rb_cBinlogEvent, "PRE_GA_WRITE_ROWS_EVENT",  INT2NUM(20));
+  rb_define_const(rb_cBinlogEvent, "PRE_GA_UPDATE_ROWS_EVENT", INT2NUM(21));
+  rb_define_const(rb_cBinlogEvent, "PRE_GA_DELETE_ROWS_EVENT", INT2NUM(22));
+  rb_define_const(rb_cBinlogEvent, "WRITE_ROWS_EVENT",         INT2NUM(23));
+  rb_define_const(rb_cBinlogEvent, "UPDATE_ROWS_EVENT",        INT2NUM(24));
+  rb_define_const(rb_cBinlogEvent, "DELETE_ROWS_EVENT",        INT2NUM(25));
+  rb_define_const(rb_cBinlogEvent, "INCIDENT_EVENT",           INT2NUM(26));
+  rb_define_const(rb_cBinlogEvent, "USER_DEFINED",             INT2NUM(27));
+
+  ruby::binlog::Client::init();
+  ruby::binlog::QueryEvent::init();
+  ruby::binlog::RotateEvent::init();
+  ruby::binlog::FormatEvent::init();
+  ruby::binlog::UserVarEvent::init();
+  ruby::binlog::TableMapEvent::init();
+  ruby::binlog::RowEvent::init();
+  ruby::binlog::IntVarEvent::init();
+  ruby::binlog::IncidentEvent::init();
+  ruby::binlog::XidEvent::init();
+  ruby::binlog::UnimplementedEvent::init();
+}