em-mysqlplus 0.1.2

data/README.md

@@ -0,0 +1,43 @@
+# EM-MySQL (Plus)
+
+EventMachine wrapper for the C-based MySQL / MySQLPlus Ruby gems, which provides
+callbacks, errbacks and all other niceties of EventMachine while keeping the API
+of the original C-based MySQL gem. 
+
+Features:
+
+ * Maintains C-based mysql gem API
+ * Deferrables for every query with callback & errback
+ * Connection query queue - pile 'em up!
+ * Auto-reconnect on disconnects
+ * Auto-retry on deadlocks
+
+## Example usage:
+   > gem install em-mysqlplus
+   > irb -r em-mysqlplus
+
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost')
+      query = conn.query("select 1+1")
+      query.callback { |res| p res.all_hashes }
+      query.errback  { |res| p res.all_hashes }
+    }
+
+## Query queueing:
+
+  	EventMachine.run {
+	  conn = EventMachine::MySQL.new(:host => 'localhost')
+
+	  results = []
+	  conn.query("select 1") {|res| results.push res.fetch_row.first.to_i}
+	  conn.query("select 2") {|res| results.push res.fetch_row.first.to_i}
+	  conn.query("select 3") {|res| results.push res.fetch_row.first.to_i}
+
+	  EventMachine.add_timer(0.05) {
+	    p results # => [1,2,3]
+	  }
+	}
+
+# Credits
+
+Original Async MySQL driver for Ruby/EventMachine - (c) 2008 Aman Gupta (tmm1)

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "em-mysqlplus"
+    gemspec.summary = "Async MySQL driver for Ruby/Eventmachine"
+    gemspec.description = gemspec.summary
+    gemspec.email = "ilya@igvita.com"
+    gemspec.homepage = "http://github.com/igrigorik/em-mysql"
+    gemspec.authors = ["Ilya Grigorik", "Aman Gupta"]
+    gemspec.add_dependency('eventmachine', '>= 0.12.9')
+    gemspec.rubyforge_project = "em-mysqlplus"
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/em-mysqlplus.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require "eventmachine"
+
+%w[ mysql connection ].each do |file|
+  require "em-mysqlplus/#{file}"
+end

data/lib/em-mysqlplus/connection.rb

@@ -0,0 +1,140 @@
+
+class Mysql
+  def result
+    @cur_result
+  end
+end
+
+module EventMachine
+  class MySQLConnection < EventMachine::Connection
+
+    attr_reader :processing, :connected, :opts
+    alias :settings :opts
+
+    MAX_RETRIES_ON_DEADLOCKS = 10
+
+    DisconnectErrors = [
+      'query: not connected',
+      'MySQL server has gone away',
+      'Lost connection to MySQL server during query'
+    ] unless defined? DisconnectErrors
+
+    def initialize(mysql, opts, conn)
+      @conn = conn
+      @mysql = mysql
+      @fd = mysql.socket
+      @opts = opts
+      @current = nil
+      @queue = []
+      @processing = false
+      @connected = true
+
+      self.notify_readable = true
+      EM.add_timer(0){ next_query }
+    end
+
+    def notify_readable
+      if item = @current
+        sql, cblk, eblk, retries = item
+        result = @mysql.get_result
+
+        # kick off next query in the background
+        # as we process the current results
+        @current = nil
+        @processing = false
+        next_query
+
+        cblk.call(result)
+      else
+        return close
+      end
+
+    rescue Mysql::Error => e
+
+      if e.message =~ /Deadlock/ and retries < MAX_RETRIES_ON_DEADLOCKS
+        @queue << [sql, cblk, eblk, retries + 1]
+        @processing = false
+        next_query
+
+      elsif DisconnectErrors.include? e.message
+        @queue << [sql, cblk, eblk, retries + 1]
+        return close
+
+      elsif cb = (eblk || @opts[:on_error])
+        cb.call(e)
+        @processing = false
+        next_query
+
+      else
+        raise e
+      end
+    end
+
+    def unbind
+      # wait for the next tick until the current fd is removed completely from the reactor
+      #
+      # in certain cases the new FD# (@mysql.socket) is the same as the old, since FDs are re-used
+      # without next_tick in these cases, unbind will get fired on the newly attached signature as well
+      #
+      # do _NOT_ use EM.next_tick here. if a bunch of sockets disconnect at the same time, we want
+      # reconnects to happen after all the unbinds have been processed
+
+      @connected = false
+
+      EM.add_timer(0) do
+        @processing = false
+        @mysql = @conn.connect_socket(@opts)
+        @fd = @mysql.socket
+
+        @signature = EM.attach_fd(@mysql.socket, true)
+        EM.set_notify_readable @signature, true
+        EM.instance_variable_get('@conns')[@signature] = self
+        @connected = true
+        next_query
+      end
+    end
+
+    def execute(sql, cblk = nil, eblk = nil, retries = 0)
+      begin
+        if not @processing or not @connected
+          @processing = true
+          @mysql.send_query(sql)
+        else
+          @queue << [sql, cblk, eblk, retries]
+          return
+        end
+
+      rescue Mysql::Error => e
+        if DisconnectErrors.include? e.message
+          @queue << [sql, cblk, eblk, retries]
+          return close
+        else
+          raise e
+        end
+      end
+
+      @current = [sql, cblk, eblk, retries]
+    end
+
+    # mysql gem has syncronous methods such as list_dbs
+    # and others which require that we execute without callbacks
+    def method_missing(method, *args, &blk)
+      @mysql.send(method, *args, &blk) if @mysql.respond_to? method
+    end
+
+    def close
+      @connected = false
+      detach
+    end
+
+    private
+
+      def next_query
+        if @connected and !@processing and pending = @queue.shift
+          sql, cblk, eblk = pending
+          execute(sql, cblk, eblk)
+        end
+      end
+
+  end
+end

data/lib/em-mysqlplus/mysql.rb

@@ -0,0 +1,107 @@
+require "eventmachine"
+require "mysqlplus"
+require "fcntl"
+
+module EventMachine
+  class MySQL
+
+    self::Mysql = ::Mysql unless defined? self::Mysql
+
+    attr_reader :connection
+
+    def initialize(opts)
+      unless EM.respond_to?(:watch) and Mysql.method_defined?(:socket)
+        raise RuntimeError, 'mysqlplus and EM.watch are required for EventedMysql'
+      end
+
+      @settings = { :debug => false }.merge!(opts)
+      @connection = connect(@settings)
+    end
+
+    def close
+      @connection.close
+    end
+
+    def query(sql, &blk)
+      df = EventMachine::DefaultDeferrable.new
+      cb = blk || Proc.new { |r| df.succeed(r) }
+      eb = Proc.new { |r| df.fail(r) }
+
+      @connection.execute(sql, cb, eb)
+
+      df
+    end
+    alias :real_query :query
+
+    # behave as a normal mysql connection
+    def method_missing(method, *args, &blk)
+      @connection.send(method, *args)
+    end
+
+    def connect(opts)
+      if conn = connect_socket(opts)
+        debug [:connect, conn.socket, opts]
+        EM.watch(conn.socket, EventMachine::MySQLConnection, conn, opts, self)
+      else
+        # invokes :errback callback in opts before firing again
+        debug [:reconnect]
+        EM.add_timer(5) { connect opts }
+      end
+    end
+
+    # stolen from sequel
+    def connect_socket(opts)
+      conn = Mysql.init
+
+      # set encoding _before_ connecting
+      if charset = opts[:charset] || opts[:encoding]
+        conn.options(Mysql::SET_CHARSET_NAME, charset)
+      end
+
+      conn.options(Mysql::OPT_LOCAL_INFILE, 'client')
+      conn.real_connect(
+        opts[:host] || 'localhost',
+        opts[:user] || 'root',
+        opts[:password],
+        opts[:database],
+        opts[:port],
+        opts[:socket],
+        0 +
+        # XXX multi results require multiple callbacks to parse
+        # Mysql::CLIENT_MULTI_RESULTS +
+        # Mysql::CLIENT_MULTI_STATEMENTS +
+        (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
+      )
+
+      # increase timeout so mysql server doesn't disconnect us
+      # this is especially bad if we're disconnected while EM.attach is
+      # still in progress, because by the time it gets to EM, the FD is
+      # no longer valid, and it throws a c++ 'bad file descriptor' error
+      # (do not use a timeout of -1 for unlimited, it does not work on mysqld > 5.0.60)
+      conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
+
+      # we handle reconnecting (and reattaching the new fd to EM)
+      conn.reconnect = false
+
+      # By default, MySQL 'where id is null' selects the last inserted id
+      # Turn this off. http://dev.rubyonrails.org/ticket/6778
+      conn.query("set SQL_AUTO_IS_NULL=0")
+
+      # get results for queries
+      conn.query_with_result = true
+
+      conn
+    rescue Mysql::Error => e
+      if cb = opts[:errback]
+        cb.call(e)
+        nil
+      else
+        raise e
+      end
+    end
+
+    def debug(data)
+      p data if @settings[:debug]
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,5 @@
+require "rubygems"
+require "eventmachine"
+require "spec"
+
+require "lib/em-mysqlplus"

data/spec/mysql_spec.rb

@@ -0,0 +1,119 @@
+require 'helper'
+
+describe EventMachine::MySQL do
+  it "should create a new connection" do
+    EventMachine.run {
+      lambda {
+        conn = EventMachine::MySQL.new(:host => 'localhost')
+        conn.connection.connected.should be_true
+
+        conn.close
+        conn.connection.connected.should be_false
+        EventMachine.stop
+      }.should_not raise_error
+    }
+  end
+
+  it "should invoke errback on connection failure" do
+    EventMachine.run {
+      lambda {
+        conn = EventMachine::MySQL.new({
+            :host => 'localhost',
+            :port => 20000,
+            :socket => '',
+            :errback => Proc.new {
+              EventMachine.stop
+            }
+          })
+      }.should_not raise_error
+    }
+  end
+
+  it "should execute sql" do
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost')
+      query = conn.query("select 1")
+      query.callback { |res|
+        res.fetch_row.first.should == "1"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should accept block as query callback" do
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost')
+      conn.query("select 1") { |res|
+        res.fetch_row.first.should == "1"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "allow custom error callbacks for each query" do
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost')
+      query = conn.query("select 1 from")
+      query.errback { |res|
+        res.class.should == Mysql::Error
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "queue up queries and execute them in order" do
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost')
+
+      results = []
+      conn.query("select 1") {|res| results.push res.fetch_row.first.to_i}
+      conn.query("select 2") {|res| results.push res.fetch_row.first.to_i}
+      conn.query("select 3") {|res| results.push res.fetch_row.first.to_i}
+
+      EventMachine.add_timer(0.05) {
+        results.should == [1,2,3]
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should continue processing queries after hitting an error" do
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost')
+
+      conn.query("select 1+ from table")
+      conn.query("select 1+1") { |res|
+        res.fetch_row.first.to_i.should == 2
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should work with synchronous commands" do
+    EventMachine.run {
+      conn = EventMachine::MySQL.new(:host => 'localhost', :database => 'test')
+
+      conn.list_dbs.class.should == Array
+      conn.list_tables.class.should == Array
+      conn.quote("select '1'").should == "select \\'1\\'"
+
+      EventMachine.stop
+    }
+  end
+
+  #  it "should reconnect when disconnected" do
+  #    # to test, run:
+  #    # mysqladmin5 -u root kill `mysqladmin -u root processlist | grep "select sleep(5)" | cut -d'|' -f2`
+  #
+  #    EventMachine.run {
+  #      conn = EventMachine::MySQL.new(:host => 'localhost')
+  #
+  #      query = conn.query("select sleep(5)")
+  #      query.callback {|res|
+  #        res.fetch_row.first.to_i.should == 0
+  #        EventMachine.stop
+  #      }
+  #    }
+  #  end
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: em-mysqlplus
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Ilya Grigorik
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 9
+        version: 0.12.9
+  type: :runtime
+  version_requirements: *id001
+description: Async MySQL driver for Ruby/Eventmachine
+email: ilya@igvita.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- lib/em-mysqlplus.rb
+- lib/em-mysqlplus/connection.rb
+- lib/em-mysqlplus/mysql.rb
+- spec/helper.rb
+- spec/mysql_spec.rb
+has_rdoc: true
+homepage: http://github.com/igrigorik/em-mysql
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: em-mysqlplus
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Async MySQL driver for Ruby/Eventmachine
+test_files: 
+- spec/helper.rb
+- spec/mysql_spec.rb