em-synchrony 0.3.0.beta.1 → 1.0.0

data/lib/em-synchrony/activerecord.rb

@@ -0,0 +1,5 @@
+require 'active_record'
+require 'em-synchrony/mysql2'
+
+require 'em-synchrony/active_record/connection_adapters/em_mysql2_adapter'
+require 'em-synchrony/active_record/patches'

data/lib/em-synchrony/connection_pool.rb

@@ -48,7 +48,7 @@ module EventMachine
         def release(fiber)
           @available.push(@reserved.delete(fiber.object_id))
 
-          if pending = @pending.pop
+          if pending = @pending.shift
             pending.resume
           end
         end
@@ -62,11 +62,11 @@ module EventMachine
         # once it is complete (assumption: fiber will yield until
         # data is available, or request is complete)
         #
-        def method_missing(method, *args)
+        def method_missing(method, *args, &blk)
           async = (method[0,1] == "a")
 
           execute(async) do |conn|
-            df = conn.send(method, *args)
+            df = conn.send(method, *args, &blk)
 
             if async
               fiber = Fiber.current

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

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

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

@@ -1,5 +1,5 @@
 begin
-  require "em-http"
+  require "em-http-request"
 rescue LoadError => error
   raise "Missing EM-Synchrony dependency: gem install em-http-request"
 end
@@ -12,11 +12,15 @@ module EventMachine
          def #{type}(options = {}, &blk)
            f = Fiber.current
 
-            conn = setup_request(:#{type}, options, &blk)
-            conn.callback { f.resume(conn) }
-            conn.errback  { f.resume(conn) }
-
-            Fiber.yield
+           conn = setup_request(:#{type}, options, &blk)
+           if conn.error.nil?
+             conn.callback { f.resume(conn) }
+             conn.errback  { f.resume(conn) }
+             
+             Fiber.yield
+           else
+             conn
+           end
          end
       ]
     end

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

@@ -22,24 +22,91 @@ module EM
 
     class Collection
 
-      alias :afind :find
-      def find(selector={}, opts={})
+      #
+      # The upcoming versions of EM-Mongo change Collection#find's interface: it
+      # now returns a deferrable cursor YAY. This breaks compatibility with past
+      # versions BOO. We'll just choose based on the presence/absence of
+      # EM::Mongo::Cursor YAY
+      #
 
-        f = Fiber.current
-        cb = proc { |res| f.resume(res) }
+      #
+      # em-mongo version > 0.3.6
+      #
+      if defined?(EM::Mongo::Cursor)
 
-        skip  = opts.delete(:skip) || 0
-        limit = opts.delete(:limit) || 0
+        # afind     is the old (async) find
+        # afind_one is rewritten to call afind
+        # find      is sync, using a callback on the cursor
+        # find_one  is sync, by calling find and taking the first element.
+        # first     is sync, an alias for find_one
 
-        @connection.find(@name, skip, limit, selector, nil, &cb)
-        Fiber.yield
-      end
+        alias :afind :find
+        def find(*args)
+          f = Fiber.current
+          cursor = afind(*args)
+          cursor.to_a.callback{ |res| f.resume(res) }
+          Fiber.yield
+        end
+
+        # need to rewrite afind_one manually, as it calls 'find' (reasonably
+        # expecting it to be what is now known as 'afind')
+
+        def afind_one(spec_or_object_id=nil, opts={})
+          spec = case spec_or_object_id
+                 when nil
+                   {}
+                 when BSON::ObjectId
+                   {:_id => spec_or_object_id}
+                 when Hash
+                   spec_or_object_id
+                 else
+                   raise TypeError, "spec_or_object_id must be an instance of ObjectId or Hash, or nil"
+                 end
+          afind(spec, opts.merge(:limit => -1)).next_document
+        end
+        alias :afirst :afind_one
+
+        def find_one(selector={}, opts={})
+          opts[:limit] = 1
+          find(selector, opts).first
+        end
+        alias :first :find_one
+
+      #
+      # em-mongo version <= 0.3.6
+      #
+      else
 
-      alias :afirst :first
-      def first(selector={}, opts={})
-        opts[:limit] = 1
-        find(selector, opts).first
+        alias :afind :find
+        def find(selector={}, opts={})
+
+          f = Fiber.current
+          cb = proc { |res| f.resume(res) }
+
+          skip  = opts.delete(:skip) || 0
+          limit = opts.delete(:limit) || 0
+          order = opts.delete(:order)
+
+          @connection.find(@name, skip, limit, order, selector, nil, &cb)
+          Fiber.yield
+        end
+
+        # need to rewrite afirst manually, as it calls 'find' (reasonably
+        # expecting it to be what is now known as 'afind')
+
+        def afirst(selector={}, opts={}, &blk)
+          opts[:limit] = 1
+          afind(selector, opts) do |res|
+            yield res.first
+          end
+        end
+
+        def first(selector={}, opts={})
+          opts[:limit] = 1
+          find(selector, opts).first
+        end
       end
+
     end
 
   end

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

@@ -21,13 +21,13 @@ module EventMachine
 
         Fiber.yield
       end
-      
+
       alias :old_call_command :call_command
-      
+
+      SYNC = ['add', 'auth']
       def call_command(argv, &blk)
-        # async commands are 'a' prefixed, but do check
-        # for the 'add' command corner case (ugh)
-        if argv.first.size > 3 && argv.first[0] == 'a'
+        # async commands are 'a' prefixed
+        if (argv.first[0] == 'a') && !SYNC.include?(argv.first.to_s)
           argv[0] = argv[0].to_s.slice(1,argv[0].size)
           old_call_command(argv, &blk)
 
@@ -42,6 +42,29 @@ module EventMachine
           Fiber.yield
         end
       end
+
+      # adapted from em-redis' implementation to use
+      # the asynchronous version of mget
+      def amapped_mget(*keys)
+        self.amget(*keys) do |response|
+          result = {}
+          response.each do |value|
+            key = keys.shift
+            result.merge!(key => value) unless value.nil?
+          end
+          yield result if block_given?
+        end
+      end
+
+      def mapped_mget(*keys)
+        f = Fiber.current
+
+        self.amapped_mget(*keys) do |values|
+          f.resume(values)
+        end
+
+        Fiber.yield
+      end
     end
   end
-end
+end

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

@@ -11,14 +11,18 @@ module Memcached
       Memcached.servers = servers
 
       f = Fiber.current
+      @w = EM::Timer.new(10.0) { f.resume :error }
       @t = EM::PeriodicTimer.new(0.01) do
         if Memcached.usable?
+          @w.cancel
           @t.cancel
           f.resume(self)
         end
       end
 
-      Fiber.yield
+      r = Fiber.yield
+
+      (r == :error) ? (raise Exception.new('Cannot connect to memcached server')) : r
     end
 
     %w[add get set delete].each do |type|
@@ -30,42 +34,62 @@ module Memcached
           cb = Proc.new { |res| df.succeed(res) }
           operation Request::#{type.capitalize}, contents, &cb
 
-            df
+          df
         end
 
         def #{type}(contents, &callback)
           fiber = Fiber.current
+          paused = false
+
+          cb = Proc.new do |res|
+            if paused
+              fiber.resume(res)
+            else
+              return res
+            end
+          end
 
-          df = a#{type}(contents, &Proc.new { |res| fiber.resume(res) })
+          df = a#{type}(contents, &cb)
           df.callback &callback
 
+          paused = true
           Fiber.yield
         end
       ]
     end
 
     %w[add get set delete].each do |type|
-       class_eval %[
-         def amulti_#{type}(contents, &callback)
-           df = EventMachine::DefaultDeferrable.new
-           df.callback &callback
+      class_eval %[
+        def amulti_#{type}(contents, &callback)
+          df = EventMachine::DefaultDeferrable.new
+          df.callback &callback
+
+          cb = Proc.new { |res| df.succeed(res) }
+          multi_operation Request::#{type.capitalize}, contents, &cb
 
-           cb = Proc.new { |res| df.succeed(res) }
-           multi_operation Request::#{type.capitalize}, contents, &cb
+          df
+        end
 
-             df
-         end
+        def multi_#{type}(contents, &callback)
+          fiber = Fiber.current
+          paused = false
 
-         def multi_#{type}(contents, &callback)
-           fiber = Fiber.current
+          cb = Proc.new do |res|
+            if paused
+              fiber.resume(res)
+            else
+              return res
+            end
+          end
 
-           df = amulti_#{type}(contents, &Proc.new { |res| fiber.resume(res) })
-           df.callback &callback
+          df = amulti_#{type}(contents, &cb)
+          df.callback &callback
 
-           Fiber.yield
-         end
-       ]
-     end
+          paused = true
+          Fiber.yield
+        end
+      ]
+    end
 
   end
 end

data/lib/em-synchrony/fiber_iterator.rb

@@ -0,0 +1,18 @@
+module EventMachine
+  module Synchrony
+
+    class FiberIterator < EM::Synchrony::Iterator
+
+      # execute each iterator block within its own fiber
+      # and auto-advance the iterator after each call
+      def each(foreach=nil, after=nil, &blk)
+        fe = Proc.new do |obj, iter|
+          Fiber.new { (foreach || blk).call(obj); iter.next }.resume
+        end
+
+        super(fe, after)
+      end
+
+    end
+  end
+end

data/lib/em-synchrony/keyboard.rb

@@ -0,0 +1,33 @@
+module EventMachine
+  module Synchrony
+    class Keyboard
+      attr_reader :current_fiber, :separator
+      
+      def gets
+        @current_fiber = Fiber.current        
+        EM.open_keyboard(EventMachine::Synchrony::KeyboardHandler, self)
+        
+        Fiber.yield
+      end
+    end
+    
+    class KeyboardHandler < EM::Connection      
+      include EM::Protocols::LineText2
+      
+      def initialize(keyboard)
+        @keyboard = keyboard
+      end
+          
+      def receive_line(line)
+        # Simulate gets by adding a trailing line feed
+        @input = "#{line}#{$/}"
+        
+        close_connection
+      end
+      
+      def unbind
+        @keyboard.current_fiber.resume @input
+      end
+    end
+  end
+end

data/lib/em-synchrony/mongo.rb

@@ -11,4 +11,22 @@ silence_warnings do
     Mutex = ::EventMachine::Synchrony::Thread::Mutex
     ConditionVariable = ::EventMachine::Synchrony::Thread::ConditionVariable
   end
-end
+
+  class Mongo::Pool
+    TCPSocket = ::EventMachine::Synchrony::TCPSocket
+    Mutex = ::EventMachine::Synchrony::Thread::Mutex
+    ConditionVariable = ::EventMachine::Synchrony::Thread::ConditionVariable
+  end
+
+  class EventMachine::Synchrony::MongoTimeoutHandler
+    def self.timeout(op_timeout, ex_class, &block)
+      f = Fiber.current
+      timer = EM::Timer.new(op_timeout) { f.resume(nil) }
+      res = block.call
+      timer.cancel
+      res
+    end
+  end
+
+  Mongo::TimeoutHandler = EventMachine::Synchrony::MongoTimeoutHandler
+end

data/lib/em-synchrony/mysql2.rb

@@ -0,0 +1,25 @@
+begin
+  require 'mysql2/em'
+rescue LoadError => error
+  raise 'Missing EM-Synchrony dependency: gem install mysql2'
+end
+
+module Mysql2
+  module EM
+    class Client
+
+      alias :aquery :query
+      def query(sql, opts={})
+        deferable = aquery(sql, opts)
+
+        f = Fiber.current
+        deferable.callback { |res| f.resume(res) }
+        deferable.errback  { |err| f.resume(err) }
+
+        Fiber.yield.tap do |result|
+          raise result if result.is_a?(::Exception)
+        end
+      end
+    end
+  end
+end