em-synchrony 0.1.5 → 0.2.0

data/examples/nethttp.rb

@@ -0,0 +1,13 @@
+require "lib/em-synchrony"
+require "net/http"
+
+$VERBOSE = nil
+
+EM.synchrony do
+  # monkey patch default Socket code to use EventMachine Sockets instead
+  TCPSocket = EventMachine::Synchrony::TCPSocket
+
+  Net::HTTP.get_print 'www.google.com', '/index.html'
+
+  EM.stop
+end

data/lib/em-synchrony.rb

@@ -8,9 +8,11 @@ rescue LoadError => error
   raise error unless defined? Fiber
 end
 
+require "em-synchrony/thread"
 require "em-synchrony/em-multi"
+require "em-synchrony/tcpsocket"
 require "em-synchrony/connection_pool"
-# require "em-synchrony/iterator" # iterators are not release in EM yet
+require "em-synchrony/iterator"  unless EventMachine::VERSION >= '0.12.10'
 
 module EventMachine
 
@@ -24,4 +26,36 @@ module EventMachine
     self.run(context, tail)
   end
 
+  module Synchrony
+
+    # sync is a close relative to inclineCallbacks from Twisted (Python)
+    #
+    # Synchrony.sync allows you to write sequential code while using asynchronous
+    # or callback-based methods under the hood. Example:
+    #
+    # result = EM::Synchrony.sync EventMachine::HttpRequest.new(URL).get
+    # p result.response
+    #
+    # As long as the asynchronous function returns a Deferrable object, which
+    # has a "callback" and an "errback", the sync methond will automatically
+    # yield and automatically resume your code (via Fibers) when the call
+    # either succeeds or fails. You do not need to patch or modify the
+    # Deferrable object, simply pass it to EM::Synchrony.sync
+    #
+    def self.sync(df)
+      f = Fiber.current
+      df.callback { |r| f.resume(r) }
+      df.errback { |r| f.resume(r) }
+
+      Fiber.yield
+    end
+
+    # a Fiber-aware sleep function using an EM timer
+    def self.sleep( secs )
+      fiber = Fiber.current
+      EM::Timer.new(secs) {  fiber.resume  }
+      Fiber.yield
+    end
+  end
+
 end

data/lib/em-synchrony/connection_pool.rb

@@ -43,7 +43,7 @@ module EventMachine
         end
 
         # Release connection assigned to the supplied fiber and
-        # resume any other pending connections (which will 
+        # resume any other pending connections (which will
         # immediately try to run acquire on the pool)
         def release(fiber)
           @available.push(@reserved.delete(fiber.object_id))
@@ -73,7 +73,7 @@ module EventMachine
               df.callback { release(fiber) }
               df.errback { release(fiber) }
             end
-            
+
             df
           end
         end

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

@@ -1,8 +1,10 @@
+require 'cgi'
+
 begin
   require "em-synchrony/em-http"
   require "bitly"
 rescue LoadError => error
-  raise "Missing EM-Synchrony dependencies: gem install em-http-request; gem install bitly -v=0.4.0"
+  raise "Missing EM-Synchrony dependencies: gem install em-http-request; gem install bitly -v=0.5.0"
 end
 
 module Bitly
@@ -23,4 +25,34 @@ module Bitly
       end
     end
   end
+  
+  module V3
+    class Client
+      class << self
+        def get(method, query)
+          query_values=[]
+          query[:query].each do |key, value|
+            query_values << "#{key}=#{CGI::escape(value.to_s)}"
+          end
+          query_values=query_values.join('&')
+          request=(method[0]=='/' ? "#{base_uri}#{method}" : method)
+          request=(request.include?('?') ? "#{request}&#{query_values}" :  "#{request}?#{query_values}")
+          
+          http = EventMachine::HttpRequest.new(request).get(:timeout => 100)
+          response = if (http.response_header.status == 200)
+            Crack::JSON.parse(http.response)
+          else
+            {'errorMessage' => 'JSON Parse Error(Bit.ly messed up)', 'errorCode' => 69, 'statusCode' => 'ERROR'}
+          end      
+          
+          if response['status_code'] == 200
+            return response
+          else
+            raise BitlyError.new(response['status_txt'], response['status_code'])
+          end
+          
+        end
+      end
+    end
+  end	
 end

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

@@ -0,0 +1,19 @@
+module EventMachine::Protocols::Memcache
+  %w[delete get set].each do |type|
+    module_eval %[
+      alias :a#{type} :#{type}
+      def #{type}(*params, &blk)
+        f = Fiber.current
+        self.a#{type}(*params) { |*cb_params| f.resume(*cb_params) }
+
+        Fiber.yield
+      end
+    ]
+  end
+
+  alias :aget_hash :get_hash
+  def get_hash(*keys)
+    index = 0
+    get(*keys).inject({}) { |h,v| h[keys[index]] = v; index += 1; h }
+  end
+end

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

@@ -0,0 +1,46 @@
+begin
+  require "em-mongo"
+rescue LoadError => error
+  raise "Missing EM-Synchrony dependency: gem install em-mongo"
+end
+
+module EM
+  module Mongo
+
+    class Connection
+      def initialize(host = DEFAULT_IP, port = DEFAULT_PORT, timeout = nil, opts = {})
+        f = Fiber.current
+
+        @em_connection = EMConnection.connect(host, port, timeout, opts)
+        @db = {}
+
+        # establish connection before returning
+        EM.next_tick { f.resume }
+        Fiber.yield
+      end
+    end
+
+    class Collection
+
+      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
+
+        @connection.find(@name, skip, limit, selector, nil, &cb)
+        Fiber.yield
+      end
+
+      alias :afirst :first
+      def first(selector={}, opts={})
+        opts[:limit] = 1
+        find(selector, opts).first
+      end
+    end
+
+  end
+end

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

@@ -13,23 +13,27 @@ module EventMachine
       def add(name, conn)
         fiber = Fiber.current
         conn.callback { @responses[:callback][name] = conn; check_progress(fiber) }
-        conn.errback  { @responses[:errback][name] = conn;  check_progress(fiber) }
+        conn.errback  { @responses[:errback][name]  = conn; check_progress(fiber) }
 
         @requests.push(conn)
       end
 
+      def finished?
+        (@responses[:callback].size + @responses[:errback].size) == @requests.size
+      end
+
       def perform
-        Fiber.yield
+        Fiber.yield unless finished?
       end
 
       protected
 
         def check_progress(fiber)
-          if (@responses[:callback].size + @responses[:errback].size) == @requests.size
+          if finished?
             succeed
 
             # continue processing
-            fiber.resume(self)
+            fiber.resume(self) if fiber.alive? && fiber != Fiber.current
           end
         end
     end

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

@@ -1,7 +1,8 @@
 begin
+  require "mysqlplus"
   require "em-mysqlplus"
 rescue LoadError => error
-  raise "Missing EM-Synchrony dependency: gem install em-mysqlplus"
+  raise "Missing EM-Synchrony dependency: gem install mysqlplus, gem install em-mysqlplus"
 end
 
 module EventMachine
@@ -17,7 +18,9 @@ module EventMachine
 
       @connection.execute(sql, cb, eb)
 
-      Fiber.yield
+      result = Fiber.yield
+      raise result if Mysql::Error == result.class
+      result
     end
 
   end

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

@@ -0,0 +1,45 @@
+begin
+  require 'em-redis'
+rescue LoadError => error
+  raise 'Missing EM-Synchrony dependency: gem install em-redis'
+end
+
+module EventMachine
+  module Protocols
+    module Redis
+      attr_reader :connected
+
+      class << self
+        alias :aconnect :connect
+      end
+
+      def self.connect(*args)
+        f = Fiber.current
+
+        conn = self.aconnect(*args)
+        conn.callback { f.resume(conn) }
+
+        Fiber.yield
+      end
+
+      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'
+          argv[0] = argv[0].to_s.slice(1,argv[0].size)
+          callback { raw_call_command(argv, &blk) }
+
+        else
+          # wrap response blocks into fiber callbacks
+          # to emulate the sync api
+          f = Fiber.current
+          blk = proc { |v| v } if !block_given?
+          clb = proc { |v| f.resume(blk.call(v)) }
+
+          callback { raw_call_command(argv, &clb) }
+          Fiber.yield
+        end
+      end
+    end
+  end
+end

data/lib/em-synchrony/mongo.rb

@@ -0,0 +1,14 @@
+begin
+  require "mongo/connection"
+rescue LoadError => error
+  raise "Missing EM-Synchrony dependency: gem install mongo"
+end
+
+# monkey-patch Mongo to use em-synchrony's socket and thread classs
+silence_warnings do
+  class Mongo::Connection
+    TCPSocket = ::EventMachine::Synchrony::TCPSocket
+    Mutex = ::EventMachine::Synchrony::Thread::Mutex
+    ConditionVariable = ::EventMachine::Synchrony::Thread::ConditionVariable
+  end
+end

data/lib/em-synchrony/mongoid.rb

@@ -0,0 +1,12 @@
+require "em-synchrony/mongo"
+
+# disable mongoid connection initializer
+if defined? Rails
+  module Rails
+    module Mongoid
+      class Railtie < Rails::Railtie
+        initializers.delete_if { |i| i.name == 'verify that mongoid is configured' }
+      end
+    end
+  end
+end

data/lib/em-synchrony/tcpsocket.rb

@@ -0,0 +1,110 @@
+module EventMachine
+  module Synchrony
+    class TCPSocket < Connection
+      class << self
+        alias_method :_old_new, :new
+        def new(*args)
+          if args.size == 1
+            _old_new *args
+          else
+            socket = EventMachine::connect( *args[0..1], self )
+            raise SocketError unless socket.sync(:in)  # wait for connection
+            socket
+          end
+        end
+        alias :open :new
+      end
+
+      def post_init
+        @in_buff, @out_buff = '', ''
+        @in_req = @out_req = nil
+      end
+
+      def closed?
+        @in_req.nil? && @out_req.nil?
+      end
+
+      # direction must be one of :in or :out
+      def sync(direction)
+        req = self.instance_variable_set "@#{direction.to_s}_req", EventMachine::DefaultDeferrable.new
+        EventMachine::Synchrony.sync req
+      end
+
+      # TCPSocket interface
+      def setsockopt(level, name, value); end
+
+      def send(msg, flags = 0)
+        raise "Unknown flags in send(): #{flags}"  if flags.nonzero?
+        len = msg.bytesize
+        write_data(msg) or sync(:out) or raise(IOError)
+        len
+      end
+      alias_method :write, :send
+
+      def read(num_bytes = 16*1024, dest = nil)
+        read_data(num_bytes, dest) or sync(:in) or raise(IOError)
+      end
+      alias_method :read_nonblock, :read
+      alias_method :recv, :read
+
+      def close
+        close_connection true
+        @in_req = @out_req = nil
+      end
+
+      # EventMachine interface
+      def connection_completed
+        @in_req.succeed self
+      end
+
+      def unbind
+        @in_req.fail  nil if @in_req
+        @out_req.fail nil if @out_req
+      end
+
+      def receive_data(data)
+        @in_buff << data
+        if @in_req && (data = read_data)
+          @in_req.succeed data
+        end
+      end
+
+      protected
+        def read_data(num_bytes = nil, dest = nil)
+          @read_bytes = num_bytes  if num_bytes
+          @read_dest = dest  if dest
+          if @in_buff.size > 0
+            data = @in_buff.slice!(0, @read_bytes)
+            @read_bytes = 0
+
+            if @read_dest
+              @read_dest.replace data
+              @read_dest = nil
+            end
+            data
+          else
+            nil
+          end
+        end
+
+        def write_data(data = nil)
+          @out_buff += data if data
+
+          loop do
+            if @out_buff.empty?
+              @out_req.succeed true if @out_req
+              return true
+            end
+
+            if self.get_outbound_data_size > EventMachine::FileStreamer::BackpressureLevel
+              EventMachine::next_tick { write_data }
+              return false
+            else
+              len = [@out_buff.bytesize, EventMachine::FileStreamer::ChunkSize].min
+              self.send_data @out_buff.slice!( 0, len )
+            end
+          end
+        end
+    end
+  end
+end

data/lib/em-synchrony/thread.rb

@@ -0,0 +1,26 @@
+module EventMachine
+  module Synchrony
+    module Thread
+
+      # Fiber-aware drop-in replacements for thread objects
+      class Mutex
+        def synchronize( &blk )
+          blk.call
+        end
+      end
+
+      class ConditionVariable
+        def wait( mutex )
+          @deferrable = EventMachine::DefaultDeferrable.new
+          EventMachine::Synchrony.sync @deferrable
+          @deferrable = nil
+        end
+
+        def signal
+          @deferrable and @deferrable.succeed
+        end
+      end
+
+    end
+  end
+end