em-synchrony 1.0.0 → 1.0.1

data/lib/em-synchrony/activerecord.rb

@@ -1,5 +1,103 @@
-require 'active_record'
-require 'em-synchrony/mysql2'
-
-require 'em-synchrony/active_record/connection_adapters/em_mysql2_adapter'
-require 'em-synchrony/active_record/patches'
+require 'em-synchrony'
+require 'active_record'
+require 'active_record/connection_adapters/abstract/connection_pool'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'em-synchrony/thread'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionPool
+      def connection
+        _fibered_mutex.synchronize do
+          @reserved_connections[current_connection_id] ||= checkout
+        end
+      end
+
+      def _fibered_mutex
+        @fibered_mutex ||= EM::Synchrony::Thread::Mutex.new
+      end
+    end
+  end
+end
+
+module EM::Synchrony
+  module ActiveRecord
+    module Client
+      def open_transactions
+        @open_transactions ||= 0
+      end
+
+      def open_transactions=(v)
+        @open_transactions = v
+      end
+
+      def acquired_for_connection_pool
+        @acquired_for_connection_pool ||= 0
+      end
+
+      def acquired_for_connection_pool=(v)
+        @acquired_for_connection_pool = v
+      end
+    end
+    
+    module Adapter
+      def configure_connection
+        nil
+      end
+
+      def transaction(*args, &blk)
+        @connection.execute(false) do |conn|
+          super
+        end
+      end
+
+      def real_connection
+        @connection.connection
+      end
+
+      def open_transactions
+        real_connection.open_transactions
+      end
+
+      def increment_open_transactions
+        real_connection.open_transactions += 1
+      end
+
+      def decrement_open_transactions
+        real_connection.open_transactions -= 1
+      end
+    end
+
+    class ConnectionPool < EM::Synchrony::ConnectionPool
+
+      # consider connection acquired
+      def execute(async)
+        f = Fiber.current
+        begin
+          conn = acquire(f)
+          conn.acquired_for_connection_pool += 1
+          yield conn
+        ensure
+          conn.acquired_for_connection_pool -= 1
+          release(f) if !async && conn.acquired_for_connection_pool == 0
+        end
+      end
+
+      def acquire(fiber)
+        return @reserved[fiber.object_id] if @reserved[fiber.object_id]
+        super
+      end
+
+      def connection
+        acquire(Fiber.current)
+      end
+
+      # via method_missing affected_rows will be recognized as async method
+      def affected_rows(*args, &blk)
+        execute(false) do |conn|
+          conn.send(:affected_rows, *args, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/em-synchrony/amqp.rb

@@ -0,0 +1,180 @@
+begin
+  require "amqp"
+  require "amq/protocol"
+rescue LoadError => error
+  raise "Missing EM-Synchrony dependency: gem install amqp"
+end
+
+module EventMachine
+  module Synchrony
+    module AMQP
+      class Error < RuntimeError; end
+
+      class << self
+        def sync &blk
+          fiber = Fiber.current
+          blk.call(fiber)
+          Fiber.yield
+        end
+
+        def sync_cb fiber
+          lambda do |*args|
+            if fiber == Fiber.current
+              return *args
+            else
+              fiber.resume *args
+            end
+          end
+        end
+
+        %w[connect start run].each do |type|
+          line = __LINE__ + 2
+          code = <<-EOF
+            def #{type}(*params)
+              sync { |f| ::AMQP.#{type}(*params, &sync_cb(f)) }
+            end
+          EOF
+          module_eval(code, __FILE__, line)
+        end
+      end
+
+      class Channel < ::AMQP::Channel
+        def initialize(*params, &block)
+          f = Fiber.current
+          super(*params, &EM::Synchrony::AMQP.sync_cb(f))
+          channel, open_ok = Fiber.yield
+          raise Error.new unless open_ok.is_a?(::AMQ::Protocol::Channel::OpenOk)
+          channel
+        end
+
+        %w[direct fanout topic headers].each do |type|
+          line = __LINE__ + 2
+          code = <<-EOF
+            alias :a#{type} :#{type}
+            def #{type}(name = 'amq.#{type}', opts = {})
+              if exchange = find_exchange(name)
+                extended_opts = Exchange.add_default_options(:#{type}, name, opts, nil)
+                validate_parameters_match!(exchange, extended_opts)
+                exchange
+              else
+                register_exchange(Exchange.new(self, :#{type}, name, opts))
+              end
+            end
+          EOF
+          module_eval(code, __FILE__, line)
+        end
+
+        alias :aqueue! :queue!
+        def queue!(name, opts = {})
+          queue = Queue.new(self, name, opts)
+          register_queue(queue)
+        end
+
+        %w[flow recover tx_select tx_commit tx_rollback reset]
+        .each do |type|
+          line = __LINE__ + 2
+          code = <<-EOF
+            alias :a#{type} :#{type}
+            def #{type}(*params)
+              EM::Synchrony::AMQP.sync { |f| self.a#{type}(*params, &EM::Synchrony::AMQP.sync_cb(f)) }
+            end
+          EOF
+          module_eval(code, __FILE__, line)
+        end
+      end
+
+      class Consumer < ::AMQP::Consumer
+        alias :aon_delivery :on_delivery
+        def on_delivery(&block)
+          Fiber.new do
+            aon_delivery(&EM::Synchrony::AMQP.sync_cb(Fiber.current))
+            loop { block.call(Fiber.yield) }
+          end.resume
+          self
+        end
+
+        alias :aconsume :consume
+        def consume(nowait = false)
+          ret = EM::Synchrony::AMQP.sync { |f| self.aconsume(nowait, &EM::Synchrony::AMQP.sync_cb(f)) }
+          raise Error.new(ret.to_s) unless ret.is_a?(::AMQ::Protocol::Basic::ConsumeOk)
+          self
+        end
+
+        alias :aresubscribe :resubscribe
+        def resubscribe
+          EM::Synchrony::AMQP.sync { |f| self.aconsume(&EM::Synchrony::AMQP.sync_cb(f)) }
+          self
+        end
+
+        alias :acancel :cancel
+        def cancel(nowait = false)
+          EM::Synchrony::AMQP.sync { |f| self.aconsume(nowait, &EM::Synchrony::AMQP.sync_cb(f)) }
+          self
+        end
+      end
+
+      class Exchange < ::AMQP::Exchange
+        def initialize(channel, type, name, opts = {}, &block)
+          f = Fiber.current
+          super(channel, type, name, opts, &EM::Synchrony::AMQP.sync_cb(f))
+          exchange, declare_ok = Fiber.yield
+          raise Error.new unless declare_ok.is_a?(::AMQ::Protocol::Exchange::DeclareOk)
+          exchange
+        end
+
+        alias :apublish :publish
+        def publish payload, options = {}
+          apublish(payload, options)
+        end
+
+        alias :adelete :delete
+        def delete(opts = {})
+          EM::Synchrony::AMQP.sync { |f| adelete(opts, &EM::Synchrony::AMQP.sync_cb(f)) }
+        end
+      end
+
+      class Queue < ::AMQP::Queue
+        def initialize(*params)
+          f = Fiber.current
+          super(*params, &EM::Synchrony::AMQP.sync_cb(f))
+          queue, declare_ok = Fiber.yield
+          raise Error.new unless declare_ok.is_a?(::AMQ::Protocol::Queue::DeclareOk)
+          queue
+        end
+
+        alias :asubscribe :subscribe
+        def subscribe &block
+          Fiber.new do
+            asubscribe(&EM::Synchrony::AMQP.sync_cb(Fiber.current))
+            loop { block.call(Fiber.yield) }
+          end.resume
+        end
+
+        %w[bind rebind unbind delete purge pop unsubscribe status].each do |type|
+          line = __LINE__ + 2
+          code = <<-EOF
+            alias :a#{type} :#{type}
+            def #{type}(*params)
+              EM::Synchrony::AMQP.sync { |f| self.a#{type}(*params, &EM::Synchrony::AMQP.sync_cb(f)) }
+            end
+          EOF
+          module_eval(code, __FILE__, line)
+        end
+      end
+
+      class Session < ::AMQP::Session
+        %w[disconnect].each do |type|
+          line = __LINE__ + 2
+          code = <<-EOF
+            alias :a#{type} :#{type}
+            def #{type}(*params)
+              EM::Synchrony::AMQP.sync { |f| self.a#{type}(*params, &EM::Synchrony::AMQP.sync_cb(f)) }
+            end
+          EOF
+          module_eval(code, __FILE__, line)
+        end
+      end
+      ::AMQP.client = ::EM::Synchrony::AMQP::Session
+    end
+  end
+end

data/lib/em-synchrony/connection_pool.rb

@@ -2,6 +2,8 @@ module EventMachine
   module Synchrony
 
     class ConnectionPool
+      undef :send
+
       def initialize(opts, &block)
         @reserved  = {}   # map of in-progress connections
         @available = []   # pool of free connections
@@ -32,7 +34,6 @@ module EventMachine
         # - if connection is available, pass it back to the calling block
         # - if pool is full, yield the current fiber until connection is available
         def acquire(fiber)
-
           if conn = @available.pop
             @reserved[fiber.object_id] = conn
             conn
@@ -66,7 +67,7 @@ module EventMachine
           async = (method[0,1] == "a")
 
           execute(async) do |conn|
-            df = conn.send(method, *args, &blk)
+            df = conn.__send__(method, *args, &blk)
 
             if async
               fiber = Fiber.current

data/lib/em-synchrony/core_ext.rb

@@ -0,0 +1,10 @@
+module Kernel
+  if !self.methods.include?(:silence_warnings)
+    def silence_warnings
+      old_verbose, $VERBOSE = $VERBOSE, nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/em-synchrony/em-hiredis.rb

@@ -1,24 +1,103 @@
-begin
-  require 'em-hiredis'
-rescue LoadError => error
-  raise 'Missing EM-Synchrony dependency: gem install em-hiredis'
-end
-
-module EventMachine
-  module Hiredis
-    class Connection
-      attr_reader :connected
-
-      def self.connect(host = 'localhost', port = 6379)
-        conn = new(host, port)
-        EM::Synchrony.sync conn
-        conn
-      end
-
-      alias :old_method_missing :method_missing
-      def method_missing(sym, *args)
-        EM::Synchrony.sync old_method_missing(sym, *args)
-      end
-    end
-  end
-end
+begin
+  require 'em-hiredis'
+rescue LoadError => error
+  raise 'Missing EM-Synchrony dependency: gem install em-hiredis'
+end
+
+module EventMachine
+  module Hiredis
+
+    def self.connect(uri = nil)
+      client = setup(uri)
+      EM::Synchrony.sync client.connect
+      client
+    end
+
+    class Client
+      def self.connect(host = 'localhost', port = 6379)
+        conn = new(host, port)
+        EM::Synchrony.sync conn.connect
+        conn
+      end
+
+      def connect
+        @connection = EM.connect(@host, @port, Connection, @host, @port)
+
+        @connection.on(:closed) do
+          if @connected
+            @defs.each { |d| d.fail("Redis disconnected") }
+            @defs = []
+            @deferred_status = nil
+            @connected = false
+            unless @closing_connection
+              @reconnecting = true
+              reconnect
+            end
+          else
+            unless @closing_connection
+              EM.add_timer(1) { reconnect }
+            end
+          end
+        end
+
+        @connection.on(:connected) do
+          Fiber.new do
+            @connected = true
+
+            auth(@password) if @password
+            select(@db) if @db
+
+            @subs.each { |s| method_missing(:subscribe, s) }
+            @psubs.each { |s| method_missing(:psubscribe, s) }
+            succeed
+
+            if @reconnecting
+              @reconnecting = false
+              emit(:reconnected)
+            end
+          end.resume
+        end
+
+        @connection.on(:message) do |reply|
+          if RuntimeError === reply
+            raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
+            deferred = @defs.shift
+            deferred.fail(reply) if deferred
+          else
+            if reply && PUBSUB_MESSAGES.include?(reply[0]) # reply can be nil
+              kind, subscription, d1, d2 = *reply
+
+              case kind.to_sym
+              when :message
+                emit(:message, subscription, d1)
+              when :pmessage
+                emit(:pmessage, subscription, d1, d2)
+              end
+            else
+              if @defs.empty?
+                if @monitoring
+                  emit(:monitor, reply)
+                else
+                  raise "Replies out of sync: #{reply.inspect}"
+                end
+              else
+                deferred = @defs.shift
+                deferred.succeed(reply) if deferred
+              end
+            end
+          end
+        end
+
+        @connected = false
+        @reconnecting = false
+
+        return self
+      end
+
+      alias :old_method_missing :method_missing
+      def method_missing(sym, *args)
+        EM::Synchrony.sync old_method_missing(sym, *args)
+      end
+    end
+  end
+end