em-synchrony 1.0.1 → 1.0.2

data/lib/em-synchrony.rb

@@ -78,7 +78,7 @@ module EventMachine
     # continue using synchrony methods
     #
     def self.add_timer(interval, &blk)
-      EM.add_timer(interval) do
+      EM::Timer.new(interval) do
         Fiber.new { blk.call }.resume
       end
     end

data/lib/em-synchrony/activerecord.rb

@@ -1,103 +1,103 @@
-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
+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

@@ -1,180 +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
+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