em-synchrony 0.1.1

data/README.md

@@ -0,0 +1,92 @@
+# EM-Synchrony
+
+Collection of convenience classes and patches to common EventMachine clients to 
+make them Fiber aware and friendly. Word of warning: even though fibers have been
+backported to Ruby 1.8.x, these classes assume Ruby 1.9 (if you're using fibers
+in production, you should be on 1.9 anyway) 
+
+Features:
+
+ * Fiber aware connection pool with sync/async query support
+ * Multi request interface which accepts any callback enabled client
+ * em-http-request: .get, etc are synchronous, while .aget, etc are async
+ * em-mysqlplus: .query is synchronous, while .aquery is async
+ * remcached: .get, etc, and .multi_* methods are synchronous
+
+## Example with async em-http client:
+
+	EventMachine.run do
+      Fiber.new {
+        res = EventMachine::HttpRequest.new("http://www.postrank.com").get
+		
+		p "Look ma, no callbacks!"
+		p res
+
+        EventMachine.stop
+      }.resume
+    end
+
+## Example with multi-request async em-http client:
+
+	EventMachine.run do
+	  Fiber.new {
+		
+ 	    multi = EventMachine::Synchrony::Multi.new
+        multi.add :a, EventMachine::HttpRequest.new("http://www.postrank.com").aget
+        multi.add :b, EventMachine::HttpRequest.new("http://www.postrank.com").apost
+        res = multi.perform
+	
+		p "Look ma, no callbacks, and parallel requests!"
+		p res
+
+	    EventMachine.stop
+	  }.resume
+	end
+
+## Example connection pool shared by a fiber:
+
+	EventMachine.run do
+
+	  db = EventMachine::Synchrony::ConnectionPool.new(size: 2) do
+	    EventMachine::MySQL.new(host: "localhost")
+	  end
+
+	  Fiber.new {
+	    start = now
+
+	    multi = EventMachine::Synchrony::Multi.new
+	    multi.add :a, db.aquery("select sleep(1)")
+	    multi.add :b, db.aquery("select sleep(1)")
+	    res = multi.perform
+
+		p "Look ma, no callbacks, and parallel requests!"
+		p res
+
+	    EventMachine.stop
+	  }.resume
+	end
+
+# License
+
+(The MIT License)
+
+Copyright (c) 2010 Ilya Grigorik
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "em-synchrony"
+    gemspec.summary = "Fiber aware EventMachine libraries"
+    gemspec.description = gemspec.summary
+    gemspec.email = "ilya@igvita.com"
+    gemspec.homepage = "http://github.com/igrigorik/em-synchrony"
+    gemspec.authors = ["Ilya Grigorik"]
+    gemspec.required_ruby_version = ">= 1.9"
+    gemspec.add_dependency('eventmachine', '>= 0.12.9')
+    gemspec.rubyforge_project = "em-synchrony"
+  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.1

data/lib/em-synchrony.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require "rubygems"
+require "eventmachine"
+require "fiber"
+
+require "em-synchrony/em-multi"
+require "em-synchrony/em-http"
+require "em-synchrony/em-mysql"
+# require "em-synchrony/em-jack"
+require "em-synchrony/em-remcached"
+
+require "em-synchrony/connection_pool"

data/lib/em-synchrony/connection_pool.rb

@@ -0,0 +1,83 @@
+module EventMachine
+  module Synchrony
+
+    class ConnectionPool
+      def initialize(opts, &block)
+        @reserved  = {}   # map of in-progress connections
+        @available = []   # pool of free connections
+        @pending   = []   # pending reservations (FIFO)
+
+        opts[:size].times do
+          @available.push(block.call) if block_given?
+        end
+      end
+
+      # Choose first available connection and pass it to the supplied
+      # block. This will block indefinitely until there is an available
+      # connection to service the request.
+      def execute(async)
+        f = Fiber.current
+
+        begin
+          conn = acquire(f)
+          yield conn
+        ensure
+          release(f) if not async
+        end
+      end
+
+      private
+
+        # Acquire a lock on a connection and assign it to executing fiber
+        # - 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
+          else
+            Fiber.yield @pending.push fiber
+            acquire(fiber)
+          end
+        end
+
+        # Release connection assigned to the supplied fiber and
+        # 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))
+
+          if pending = @pending.pop
+            pending.resume
+          end
+        end
+
+        # Allow the pool to behave as the underlying connection
+        #
+        # If the requesting method begins with "a" prefix, then
+        # hijack the callbacks and errbacks to fire a connection
+        # pool release whenever the request is complete. Otherwise
+        # yield the connection within execute method and release
+        # once it is complete (assumption: fiber will yield until
+        # data is available, or request is complete)
+        #
+        def method_missing(method, *args)
+          async = (method[0,1] == "a")
+
+          execute(async) do |conn|
+            df = conn.send(method, *args)
+
+            if async
+              fiber = Fiber.current
+              df.callback { release(fiber) }
+              df.errback { release(fiber) }
+            end
+            
+            df
+          end
+        end
+    end
+
+  end
+end

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

@@ -0,0 +1,18 @@
+module EventMachine
+  class HttpRequest
+     %w[get head post delete put].each do |type|
+       class_eval %[
+         alias :a#{type} :#{type}
+         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  
+         end
+      ]
+    end  
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'em-jack'
+
+# WANT: namespaced under EventMachine.. would be nice :-)
+# NOTE: no need for "pooling" since Beanstalk supports pipelining
+module EMJack
+  class Connection
+
+    alias :ause :use
+    def use(tube, &blk)
+      return if @used_tube == tube
+
+      f = Fiber.current
+
+      # WANT: per command errbacks, would be nice, instead of one global
+      # errback  = Proc.new {|r| f.resume(r) }
+
+      on_error {|r| f.resume(r)}
+
+      @used_tube = tube
+      @conn.send(:use, tube)
+      
+      # WANT: Add conditional on add_deferrable to either accept two procs, or a single block
+      #       .. two procs = callback, errback
+      add_deferrable { |r| f.resume(r) }
+      
+      Fiber.yield
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+module EventMachine
+  module Synchrony
+    class Multi
+      include EventMachine::Deferrable
+
+      attr_reader :requests, :responses
+
+      def initialize
+        @requests = []
+        @responses = {:callback => {}, :errback => {}}
+      end
+
+      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) }
+
+        @requests.push(conn)
+      end
+
+      def perform
+        Fiber.yield
+      end
+
+      protected
+
+        def check_progress(fiber)
+          if (@responses[:callback].size + @responses[:errback].size) == @requests.size
+            succeed
+
+            # continue processing
+            fiber.resume(self)
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module EventMachine
+  class MySQL
+
+    alias :aquery :query
+    def query(sql, &blk)
+      f = Fiber.current
+
+      # TODO: blk case does not work. Hmm?
+      cb = Proc.new { |r| f.resume(r) }
+      eb = Proc.new { |r| f.resume(r) }
+
+      @connection.execute(sql, cb, eb)
+
+      Fiber.yield
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+require "remcached"
+
+module Memcached
+  class << self
+
+    def connect(servers)
+      Memcached.servers = servers
+
+      f = Fiber.current
+      @t = EM::PeriodicTimer.new(0.01) do
+        if Memcached.usable?
+          @t.cancel
+          f.resume(self)
+        end
+      end
+
+      Fiber.yield
+    end
+
+    %w[add get set delete].each do |type|
+      class_eval %[
+        def a#{type}(contents, &callback)
+          df = EventMachine::DefaultDeferrable.new
+          df.callback &callback
+
+          cb = Proc.new { |res| df.succeed(res) }
+          operation Request::#{type.capitalize}, contents, &cb
+
+            df
+        end
+
+        def #{type}(contents, &callback)
+          fiber = Fiber.current
+
+          df = a#{type}(contents, &Proc.new { |res| fiber.resume(res) })
+          df.callback &callback
+
+          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
+    
+           cb = Proc.new { |res| df.succeed(res) }
+           multi_operation Request::#{type.capitalize}, contents, &cb
+    
+             df
+         end
+    
+         def multi_#{type}(contents, &callback)
+           fiber = Fiber.current
+    
+           df = amulti_#{type}(contents, &Proc.new { |res| fiber.resume(res) })
+           df.callback &callback
+    
+           Fiber.yield
+         end
+       ]
+     end
+
+  end
+end

data/spec/beanstalk_spec.rb

@@ -0,0 +1,41 @@
+require 'spec/helper'
+
+DELAY = 0.25
+
+describe EMJack do
+
+  it "should fire sequential Beanstalk requests" do
+    EventMachine.run do
+
+      Fiber.new {
+        jack = EMJack::Connection.new
+
+        r = jack.use('mytube')
+        r.should == 'mytube'
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should fire multiple requests in parallel" do
+    EventMachine.run do
+
+      Fiber.new {
+        jack = EMJack::Connection.new
+
+        multi = EventMachine::Multi.new
+        multi.add jack.ause('mytube-1')
+        multi.add jack.ause('mytube-2')
+        res = multi.perform
+        
+        res.responses.size.should == 2
+        p [:multi, res.responses]
+        
+        EventMachine.stop
+      }.resume
+
+    end
+  end
+  
+end

data/spec/connection_pool_spec.rb

@@ -0,0 +1,129 @@
+require "spec/helper/all"
+
+DELAY = 0.25
+QUERY = "select sleep(#{DELAY})"
+
+describe EventMachine::Synchrony::ConnectionPool do
+
+  it "should queue requests if pool size is exceeded" do
+    EventMachine.run do
+
+      db = EventMachine::Synchrony::ConnectionPool.new(size: 1) do
+        EventMachine::MySQL.new(host: "localhost")
+      end
+
+      Fiber.new {
+        start = now
+
+        multi = EventMachine::Synchrony::Multi.new
+        multi.add :a, db.aquery(QUERY)
+        multi.add :b, db.aquery(QUERY)
+        res = multi.perform
+
+        (now - start.to_f).should be_within(DELAY * 2 * 0.15).of(DELAY * 2)
+        res.responses[:callback].size.should == 2
+        res.responses[:errback].size.should == 0
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should execute multiple async pool requests within same fiber" do
+    EventMachine.run do
+
+      db = EventMachine::Synchrony::ConnectionPool.new(size: 2) do
+        EventMachine::MySQL.new(host: "localhost")
+      end
+
+      Fiber.new {
+        start = now
+
+        multi = EventMachine::Synchrony::Multi.new
+        multi.add :a, db.aquery(QUERY)
+        multi.add :b, db.aquery(QUERY)
+        res = multi.perform
+
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+        res.responses[:callback].size.should == 2
+        res.responses[:errback].size.should == 0
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should share connection pool between different fibers" do
+    EventMachine.run do
+
+      db = EventMachine::Synchrony::ConnectionPool.new(size: 2) do
+        EventMachine::MySQL.new(host: "localhost")
+      end
+
+      Fiber.new {
+        start = now
+        results = []
+
+        fiber = Fiber.current
+        2.times do |n|
+          Fiber.new {
+            results.push db.query(QUERY)
+            fiber.transfer if results.size == 2
+          }.resume
+        end
+
+        # wait for workers
+        Fiber.yield
+
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+        results.size.should == 2
+
+        EventMachine.stop
+      }.resume
+
+    end
+  end
+
+  it "should share connection pool between different fibers & async requests" do
+    EventMachine.run do
+
+      db = EventMachine::Synchrony::ConnectionPool.new(size: 5) do
+        EventMachine::MySQL.new(host: "localhost")
+      end
+
+      Fiber.new {
+        start = now
+        results = []
+
+        fiber = Fiber.current
+        2.times do |n|
+          Fiber.new {
+
+            multi = EventMachine::Synchrony::Multi.new
+            multi.add :a, db.aquery(QUERY)
+            multi.add :b, db.aquery(QUERY)
+            results.push multi.perform
+
+            fiber.transfer if results.size == 3
+          }.resume
+        end
+        
+        Fiber.new {
+          # execute a synchronous requests
+          results.push db.query(QUERY)
+          fiber.transfer if results.size == 3
+        }.resume
+
+        # wait for workers
+        Fiber.yield
+
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+        results.size.should == 3
+
+        EventMachine.stop
+      }.resume
+
+    end
+  end
+
+end

data/spec/helper/all.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'spec'
+require 'pp'
+
+require 'em-http'
+require 'em-mysqlplus'
+
+require 'lib/em-synchrony'
+require 'helper/tolerance_matcher'
+require 'helper/stub-http-server'
+
+def now(); Time.now.to_f; end
+
+Spec::Runner.configure do |config|
+  config.include(Sander6::CustomMatchers)
+end

data/spec/helper/stub-http-server.rb

@@ -0,0 +1,22 @@
+class StubServer
+  module Server
+    attr_accessor :response, :delay
+    def receive_data(data)
+      EM.add_timer(@delay) {
+        send_data @response
+        close_connection_after_writing
+      }
+    end
+  end
+
+  def initialize(response, delay = 0, port=8081)
+    @sig = EventMachine::start_server("127.0.0.1", port, Server) { |s|
+      s.response = response
+      s.delay = delay
+    }
+  end
+
+  def stop
+    EventMachine.stop_server @sig
+  end
+end

data/spec/helper/tolerance_matcher.rb

@@ -0,0 +1,40 @@
+#
+# courtesy of sander 6
+# - http://github.com/sander6/custom_matchers/blob/master/lib/matchers/tolerance_matchers.rb
+#
+module Sander6
+  module CustomMatchers
+    
+    class ToleranceMatcher
+      def initialize(tolerance)
+        @tolerance = tolerance
+        @target = 0
+      end
+
+      def of(target)
+        @target = target
+        self
+      end
+
+      def matches?(value)
+        @value = value
+        ((@target - @tolerance)..(@target + @tolerance)).include?(@value)
+      end
+
+      def failure_message
+        "Expected #{@value.inspect} to be within #{@tolerance.inspect} of #{@target.inspect}, but it wasn't.\n" +
+          "Difference: #{@value - @target}"
+          end
+
+      def negative_failure_message
+        "Expected #{@value.inspect} not to be within #{@tolerance.inspect} of #{@target.inspect}, but it was.\n" +
+          "Difference: #{@value - @target}"
+          end
+    end
+
+    def be_within(value)
+      Sander6::CustomMatchers::ToleranceMatcher.new(value)
+    end
+
+  end
+end

data/spec/http_spec.rb

@@ -0,0 +1,51 @@
+require "spec/helper/all"
+
+URL = "http://localhost:8081/"
+DELAY = 0.25
+
+describe EventMachine::HttpRequest do
+  it "should fire sequential requests" do
+    EventMachine.run do
+      @s = StubServer.new("HTTP/1.0 200 OK\r\nConnection: close\r\n\r\nFoo", DELAY)
+
+      Fiber.new {
+        start = now
+        order = []
+        order.push :get  if EventMachine::HttpRequest.new(URL).get
+        order.push :post if EventMachine::HttpRequest.new(URL).post
+        order.push :head if EventMachine::HttpRequest.new(URL).head
+        order.push :post if EventMachine::HttpRequest.new(URL).delete
+        order.push :put  if EventMachine::HttpRequest.new(URL).put
+
+        (now - start.to_f).should be_within(DELAY * order.size * 0.15).of(DELAY * order.size)
+        order.should == [:get, :post, :head, :post, :put]
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should fire simultaneous requests via Multi interface" do
+    EventMachine.run do
+      @s = StubServer.new("HTTP/1.0 200 OK\r\nConnection: close\r\n\r\nFoo", DELAY)
+
+      Fiber.new {
+        start = now
+
+        multi = EventMachine::Synchrony::Multi.new
+        multi.add :a, EventMachine::HttpRequest.new(URL).aget
+        multi.add :b, EventMachine::HttpRequest.new(URL).apost
+        multi.add :c, EventMachine::HttpRequest.new(URL).ahead
+        multi.add :d, EventMachine::HttpRequest.new(URL).adelete
+        multi.add :e, EventMachine::HttpRequest.new(URL).aput
+        res = multi.perform
+        
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+        res.responses[:callback].size.should == 5
+        res.responses[:errback].size.should == 0
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+end

data/spec/mysql_spec.rb

@@ -0,0 +1,93 @@
+require "spec/helper/all"
+require "em-mysqlplus"
+
+DELAY = 0.25
+QUERY = "select sleep(#{DELAY})"
+
+describe EventMachine::MySQL do
+
+  it "should fire sequential, synchronous requests" do
+    EventMachine.run do
+      Fiber.new {
+        db = EventMachine::MySQL.new(host: "localhost")
+        start = now
+        res = []
+
+        res.push db.query(QUERY)
+        res.push db.query(QUERY)
+        (now - start.to_f).should be_within(DELAY * res.size * 0.15).of(DELAY * res.size)
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should have accept a callback, errback on async queries" do
+    EventMachine.run do
+      db = EventMachine::MySQL.new(host: "localhost")
+
+      res = db.aquery(QUERY)
+      res.errback {|r| fail }
+      res.callback {|r|
+        r.all_hashes.size.should == 1
+        EventMachine.stop
+      }
+    end
+  end
+
+  it "should fire simultaneous requests via Multi interface" do
+    EventMachine.run do
+
+      db = EventMachine::Synchrony::ConnectionPool.new(size: 2) do
+        EventMachine::MySQL.new(host: "localhost")
+      end
+
+      Fiber.new {
+        start = now
+
+        multi = EventMachine::Synchrony::Multi.new
+        multi.add :a, db.aquery(QUERY)
+        multi.add :b, db.aquery(QUERY)
+        res = multi.perform
+
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+        res.responses[:callback].size.should == 2
+        res.responses[:errback].size.should == 0
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should fire sequential and simultaneous MySQL requests" do
+    EventMachine.run do
+      db = EventMachine::Synchrony::ConnectionPool.new(size: 3) do
+        EventMachine::MySQL.new(host: "localhost")
+      end
+
+      Fiber.new {
+        start = now
+        res = []
+
+        res.push db.query(QUERY)
+        res.push db.query(QUERY)
+        (now - start.to_f).should be_within(DELAY * res.size * 0.15).of(DELAY * res.size)
+
+        start = now
+
+        multi = EventMachine::Synchrony::Multi.new
+        multi.add :a, db.aquery(QUERY)
+        multi.add :b, db.aquery(QUERY)
+        multi.add :c, db.aquery(QUERY)
+        res = multi.perform
+
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+        res.responses[:callback].size.should == 3
+        res.responses[:errback].size.should == 0
+
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+end

data/spec/remcached_spec.rb

@@ -0,0 +1,51 @@
+require "spec/helper/all"
+require "remcached"
+
+describe Memcached do
+
+  it "should yield until connection is ready" do
+    EventMachine.run do
+      Fiber.new {
+        Memcached.connect %w(localhost)
+        Memcached.usable?.should be_true
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+  it "should fire sequential memcached requests" do
+    EventMachine.run do
+      Fiber.new {
+
+        Memcached.connect %w(localhost)
+        Memcached.get(key: 'hai') do |res|
+          res[:value].should match('Not found')
+        end
+
+        Memcached.set(key: 'hai', value: 'win')
+        Memcached.add(key: 'count')
+        Memcached.delete(key: 'hai')           
+        
+        EventMachine.stop
+      }.resume
+    end
+  end
+  
+  it "should fire multi memcached requests" do
+    pending "remcached borked? opened a ticket"
+    
+    EventMachine.run do
+      Fiber.new {
+
+        Memcached.connect %w(localhost)
+        
+        Memcached.multi_get([{:key => 'foo'},{:key => 'bar'}, {:key => 'test'}]) do |res|
+          p res
+        end
+                
+        EventMachine.stop
+      }.resume
+    end
+  end
+
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: em-synchrony
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-18 00:00:00 -04: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: Fiber aware EventMachine libraries
+email: ilya@igvita.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- lib/em-synchrony.rb
+- lib/em-synchrony/connection_pool.rb
+- lib/em-synchrony/em-http.rb
+- lib/em-synchrony/em-jack.rb
+- lib/em-synchrony/em-multi.rb
+- lib/em-synchrony/em-mysql.rb
+- lib/em-synchrony/em-remcached.rb
+- spec/beanstalk_spec.rb
+- spec/connection_pool_spec.rb
+- spec/helper/all.rb
+- spec/helper/stub-http-server.rb
+- spec/helper/tolerance_matcher.rb
+- spec/http_spec.rb
+- spec/mysql_spec.rb
+- spec/remcached_spec.rb
+has_rdoc: true
+homepage: http://github.com/igrigorik/em-synchrony
+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: 
+      - 1
+      - 9
+      version: "1.9"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: em-synchrony
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Fiber aware EventMachine libraries
+test_files: 
+- spec/beanstalk_spec.rb
+- spec/connection_pool_spec.rb
+- spec/helper/all.rb
+- spec/helper/stub-http-server.rb
+- spec/helper/tolerance_matcher.rb
+- spec/http_spec.rb
+- spec/mysql_spec.rb
+- spec/remcached_spec.rb