em-pg-client 0.1.0

data/BENCHMARKS.rdoc

@@ -0,0 +1,43 @@
+== Benchmarks
+
+I've done some benchmark tests[link:benchmarks/em_pg.rb] to compare fully async and blocking em-pg drivers.
+
+The goal of the test is simply to retrieve (~80000) rows from table with a lot of text data, in chunks, using parallel connections.
+The parallel method uses synchrony for simplicity.
+
+* +single+ is (eventmachine-less) job for retrieving a whole data table in
+  one query simple query "select * from resources"
+* +parallel+ chunk_row_count / concurrency] uses em-pg-client for retrieving
+  result in chunks by +chunk_row_count+ rows and using +concurrency+ parallel
+  connections
+* +blocking+ chunk_row_count / concurrency is similiar to +parallel+ except
+  that it uses special patched version of library that uses blocking
+  PGConnection methods
+
+== Environment 
+
+The machine used for test is Linux CentOS 2.6.18-194.32.1.el5xen #1 SMP with Quad Core Xeon X3360 @ 2.83GHz, 4GB RAM.
+Postgres version used: 9.0.3.
+
+== The results:
+
+    >> benchmark 1000
+                              user     system      total        real
+    single:              80.970000   0.350000  81.320000 (205.592592)
+
+    parallel 90000/1:    87.380000   0.710000  88.090000 (208.171564)
+    parallel 5000/5:     84.250000   3.760000  88.010000 (141.031289)
+    parallel 2000/10:    90.190000   4.970000  95.160000 (152.844950)
+    parallel 1000/20:    97.070000   5.390000 102.460000 (212.358631)
+
+    blocking 90000/1:    93.590000   0.610000  94.200000 (230.190776)
+    blocking 5000/5:     79.930000   1.810000  81.740000 (223.342432)
+    blocking 2000/10:    76.990000   2.820000  79.810000 (225.347169)
+    blocking 1000/20:    78.790000   3.230000  82.020000 (225.949107)
+
+As we can see the gain from using asynchronous pg client while
+using +parallel+ queries is noticeable (up to ~30%).
+
+The +blocking+ client however doesn't gain much from parallel execution.
+This was expected because it freezes eventmachine until the whole
+dataset is consumed by the client.

data/README.rdoc

@@ -0,0 +1,203 @@
+= em-pg-client
+
+Author::    Rafał Michalski  (mailto:royaltm75@gmail.com)
+
+* http://github.com/royaltm/ruby-em-pg-client
+
+== DESCRIPTION
+
+*em-pg-client* is a PostgreSQL EventMachine client wrapper for Ruby
+based on (ruby-pg)[https://bitbucket.org/ged/ruby-pg]
+
+== FEATURES
+
+* minimal changes to PG::Conncet API
+* auto reconnects on socket connection loss (like server restarts)
+* true non-blocking asynchronous processing
+* EM-Synchrony[https://github.com/igrigorik/em-synchrony] support
+
+== BUGS/LIMITATIONS
+
+* actually no ActiveRecord or Sequel support (you are welcome to contribute).
+* connecting/reconnecting operation is blocking EM
+
+== TODO:
+
+* em-synchrony ORM (ActiveRecord, Sequel and maybe Datamapper) support
+* full async connection process (low priority)
+
+== REQUIREMENTS
+
+* ruby >= 1.9
+* https://bitbucket.org/ged/ruby-pg (>= 0.13)
+* http://rubyeventmachine.com
+* (optional) EM-Synchrony[https://github.com/igrigorik/em-synchrony]
+
+== INSTALL
+
+  $ sudo gem install em-pg-client
+
+== WHY?
+
+Because until now nobody did it to fit my needs.
+I've found at least 3 other implementations of EM postgres client:
+
+* https://github.com/jzimmek/em-postgresql-sequel
+* https://github.com/leftbee/em-postgresql-adapter
+* https://github.com/jtoy/em-postgres
+
+and (except the bundled one which uses no longer maintained postgres-pr library)
+all of them have similiar flaws:
+
+* 2 of them are designed to support some ORM only (ActiveRecord or Sequel)
+  so they are EM-Synchrony only,
+* non-standard API method names,
+* no (nonexistent or non-working) autoreconnect implementation,
+* not fully supporting asynchronous PG::Connection API.
+
+The last one is worth some comment:
+
+They all use blocking methods to retrieve whole result from server
+(PGConn#block() or PGConn#get_result() which also
+blocks when there is not enough buffered data on socket).
+
+This implementation makes use of non-blocking: PGConn#is_busy and PGConn#consume_input methods.
+Depending on size of result sets and concurrency level the gain in overall speed and responsiveness of your
+application might be actually quite huge. I already have done some tests[link:BENCHMARKS.rdoc].
+
+== Thanks
+
+The greetz go to:
+- Authors[https://bitbucket.org/ged/ruby-pg/wiki/Home#!copying] of +pg+ driver (especially for its async-api)
+- Francis Cianfrocca for great reactor framework (EventMachine[https://github.com/eventmachine/eventmachine])
+- Ilya Grigorik (igrigorik[https://github.com/igrigorik]) for (untangling)[http://www.igvita.com/2010/03/22/untangling-evented-code-with-ruby-fibers/] EM with Fibers
+
+== USAGE
+
+=== BASIC
+
+  require 'pg/em'
+  
+  # no async
+  pg = PG::EM::Client.new dbname: 'test'
+  pq.query('select * from foo') do |result|
+    puts result
+  end
+  
+  # asynchronous
+  EM.run do
+    pq.query('select * from foo') do |result|
+      raise result if result.is_a? ::Exception
+      puts result
+      EM.stop
+    end
+    puts "sent"
+  end
+
+=== AUTORECONNECTING IN ASYNC MODE
+
+  EM.run do
+    pg = PG::EM::Client.new dbname: 'test'
+    
+    try_query = lambda |&blk| do
+      pq.query('select * from foo') do |result|
+        raise result if result.is_a? ::Exception
+        puts result
+        blk.call
+      end
+    end
+    try_query.call {
+      system 'pg_ctl stop -m fast'
+      system 'pg_ctl start -w'
+      EM.add_timer(1) do
+        try_query.call { EM.stop }
+      end
+    }
+  end
+
+to disable this feature call:
+
+  pg.async_autoreconnect = false
+
+or
+
+  pg = PG::EM::Client.new dbname: 'test',
+    async_autoreconnect: false
+
+=== TRUE ASYNC
+
+  EM.run do
+    pool = (1..10).map { PG::EM::Client.new dbname: 'alpha' }
+
+    togo = pool.length
+
+    pool.each_with_index do |pg, i|
+      pg.query("select * from foo") do |result|
+        puts "recv: #{i}"
+        EM.stop if (togo-=1).zero?
+      end
+      puts "sent: #{i}"
+    end
+  end
+
+=== EM-Synchrony
+
+  require 'em-synchrony/pg'
+
+  EM.synchrony do
+    pg = PG::EM::Client.new dbname: 'test'
+    pg.query('select * from foo') do |result|
+      puts result
+    end
+    EM.stop
+  end
+
+==== Handling errors
+
+  EM.synchrony do
+    begin
+      pg.query('select * from foo') do |result|
+        puts result
+      end
+    rescue PG::Error => e
+      puts "PSQL error: #{e.inspect}"
+    end
+    EM.stop
+  end
+
+==== Parallel async queries
+
+  EM.synchrony do
+    pg = EM::Synchrony::ConnectionPool.new(size: 2) do  
+      PG::EM::Client.new :dbname => 'alpha'
+    end
+    multi = EventMachine::Synchrony::Multi.new
+    multi.add :foo, pg.aquery('select * from foo') # or #async_query()
+    multi.add :bar, pg.aquery('select * from bar') # #aquery() is just an alias
+    res = multi.perform
+    p res
+    EM.stop
+  end
+
+==== Fiber Concurrency
+
+  EM.synchrony do
+    # use ConnectionPool when more Fibers will be querying at the same time!
+    pg = EM::Synchrony::ConnectionPool.new(size: 5) do  
+      PG::EM::Client.new :dbname => 'alpha'
+    end
+    counter = 0
+    EM::Synchrony::FiberIterator.new(['select * from foo']*10, 5) do |query|
+      i = counter
+      pg.query(query) do |result|
+        puts "recv: #{i}"
+      end
+      puts "sent: #{i}"
+      counter += 1
+    end
+    EM.stop
+  end
+
+== LICENCE
+
+The MIT License - Copyright (c) 2012 Rafał Michalski

data/Rakefile

@@ -0,0 +1,46 @@
+$:.unshift "lib"
+
+task :default => [:test]
+
+$gem_name = "em-pg-client"
+
+desc "Run tests"
+task :test do
+  puts "WARNING: The test needs to be run with an available local PostgreSQL server"
+  sh "rspec spec/em_client.rb"
+  sh "rspec spec/em_synchrony_client.rb"
+end
+
+desc "Build the gem"
+task :gem do
+  sh "gem build #$gem_name.gemspec"
+end
+
+desc "Install the library at local machnie"
+task :install => :gem do 
+  sh "gem install #$gem_name -l"
+end
+
+desc "Uninstall the library from local machnie"
+task :uninstall do
+  sh "gem uninstall #$gem_name"
+end
+
+desc "Clean"
+task :clean do
+  sh "rm #$gem_name*.gem" 
+end
+
+desc "Documentation"
+task :doc do
+  sh "rdoc --encoding=UTF-8 --title=em-pg-client --main=README.rdoc README.rdoc BENCHMARKS.rdoc lib/*/*.rb"
+end
+
+desc "Benchmark"
+task :benchmark do
+  require "./benchmarks/em_pg.rb"
+  [10, 100, 1000].each do |i|
+    puts "Repeat: #{i}"
+    benchmark(i)
+  end
+end

data/benchmarks/em_pg.rb

@@ -0,0 +1,93 @@
+$:.unshift('./lib')
+require 'eventmachine'
+require 'em-synchrony'
+require 'em-synchrony/pg'
+require "em-synchrony/fiber_iterator"
+require 'pp'
+require 'benchmark'
+
+$dbname = 'alpha'
+
+def benchmark(repeat=100)
+  Benchmark.bm(20) do |b|
+    b.report('single:')         { single(repeat) }
+    puts
+    b.report('parallel 90000/1:')  { parallel(repeat, 90000, 1) }
+    b.report('parallel 5000/5:')  { parallel(repeat, 5000, 5) }
+    b.report('parallel 2000/10:') { parallel(repeat, 2000, 10) }
+    b.report('parallel 1000/20:') { parallel(repeat, 1000, 20) }
+    puts
+    patch_blocking
+    b.report('blocking 90000/1:')  { parallel(repeat, 90000, 1) }
+    b.report('blocking 5000/5:')  { parallel(repeat, 5000, 5) }
+    b.report('blocking 2000/10:') { parallel(repeat, 2000, 10) }
+    b.report('blocking 1000/20:') { parallel(repeat, 1000, 20) }
+    patch_remove_blocking
+  end
+end
+
+def patch_remove_blocking
+  PG::EM::Client::Watcher.module_eval <<-EOE
+    alias_method :notify_readable, :original_notify_readable
+    undef :original_notify_readable
+  EOE
+end
+
+def patch_blocking
+  PG::EM::Client::Watcher.module_eval <<-EOE
+    alias_method :original_notify_readable, :notify_readable
+    def notify_readable
+      detach
+      begin
+        result = @client.get_last_result
+      rescue Exception => e
+        @deferrable.fail(e)
+      else
+        @deferrable.succeed(result)
+      end
+    end
+  EOE
+end
+
+# retrieve resources using single select query
+def single(repeat=1)
+  rowcount = 0
+  p = PGconn.new :dbname => $dbname
+  p.query('select count(*) from resources') do |result|
+    rowcount = result.getvalue(0,0).to_i
+  end
+  repeat.times do
+    p.query('select * from resources order by cdate') do |result|
+      $resources = result.values
+    end
+  end
+  # raise "invalid count #{$resources.length} != #{rowcount}" if $resources.length != rowcount
+end
+
+# retrieve resources using parallel queries
+def parallel(repeat=1, chunk_size=2000, concurrency=10)
+  resources = []
+  rowcount = 0
+  EM.synchrony do
+    p = EM::Synchrony::ConnectionPool.new(size: concurrency) { PG::EM::Client.new :dbname => $dbname }
+    p.query('select count(*) from resources') do |result|
+      rowcount = result.getvalue(0,0).to_i
+    end
+    offsets = (rowcount / chunk_size.to_f).ceil.times.map {|n| n*chunk_size }
+    repeat.times do
+      EM::Synchrony::FiberIterator.new(offsets, concurrency).each do |offset|
+        p.query('select * from resources order by cdate limit $1 offset $2', [chunk_size, offset]) do |result|
+          resources[offset, chunk_size] = result.values
+        end    
+      end
+    end
+    EM.stop
+  end
+  # raise "invalid count #{resources.length} != #{rowcount}" if resources.length != rowcount
+  # raise "resources != $resources" if resources != $resources
+  resources
+end
+
+if $0 == __FILE__
+  benchmark (ARGV.first || 10).to_i
+end

data/em-pg-client.gemspec

@@ -0,0 +1,25 @@
+$:.unshift "lib"
+
+Gem::Specification.new do |s|
+  s.name = "em-pg-client"
+  s.version = "0.1.0"
+  s.required_ruby_version = ">= 1.9.1"
+  s.date = "#{Time.now.strftime("%Y-%m-%d")}"
+  s.summary = "EventMachine PostgreSQL client"
+  s.email = "rafal@yeondir.com"
+  s.homepage = "http://github.com/royaltm/ruby-em-pg-client"
+  s.require_path = "lib"
+  s.description = "PostgreSQL asynchronous EventMachine client (ruby-pg) wrapper"
+  s.authors = ["Rafal Michalski"]
+  s.files = `git ls-files`.split("\n") - ['.gitignore']
+  s.test_files = Dir.glob("spec/**/*")
+  s.rdoc_options << "--title" << "em-pg-client" <<
+    "--main" << "README.rdoc"
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc", "BENCHMARKS.rdoc"]
+  s.requirements << "PostgreSQL server"
+  s.add_runtime_dependency "pg", ">= 0.13.2"
+  s.add_runtime_dependency "eventmachine", ">= 0.12.10"
+  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_development_dependency "em-synchrony", "~> 1.0.0"
+end

data/lib/em-synchrony/pg.rb

@@ -0,0 +1,45 @@
+require 'pg/em'
+module PG
+  module EM
+    class Client
+      # Author:: Rafal Michalski (mailto:royaltm75@gmail.com)
+      # Licence:: MIT License
+      #
+      # =PostgreSQL Client for EM-Synchrony
+      #
+
+      # conform to *standard*
+      alias_method :aquery, :async_query
+
+      # fiber untangled version of theese methods:
+      # - exec (aliased as query)
+      # - exec_prepared
+      # - prepare
+      %w(exec exec_prepared prepare).each do |name|
+        class_eval <<-EOD
+          def #{name}(*args, &blk)
+            if ::EM.reactor_running?
+              df = async_#{name}(*args)
+              f = Fiber.current
+              df.callback { |res| f.resume(res) }
+              df.errback  { |err| f.resume(err) }
+
+              result = Fiber.yield
+              raise result if result.is_a?(::Exception)
+              if block_given?
+                yield result 
+              else
+                result
+              end
+            else
+              super(*args, &blk)
+            end
+          end
+        EOD
+
+      end
+
+      alias_method :query, :exec
+    end
+  end
+end

data/lib/pg/em.rb

@@ -0,0 +1,124 @@
+require 'pg'
+module PG
+  module EM
+    class Client < PG::Connection
+      # == PostgreSQL EventMachine client
+      #
+      # Author:: Rafal Michalski (mailto:royaltm75@gmail.com)
+      # Licence:: MIT License
+      #
+      #
+      # PG::EM::Client is a wrapper for PG::Connection which (re)defines methods:
+      #
+      # - +async_exec+ (alias: +async_query+)
+      # - +async_prepare+
+      # - +async_exec_prepared+
+      #
+      # and following:
+      #
+      # - +exec+ (alias: +query+)
+      # - +exec_prepared+
+      # - +prepare+
+      #
+      # which autodetects if EventMachine is running and uses appropriate
+      # (async or sync) method version.
+      #
+      # Async methods might try to reset connection on connection error,
+      # you won't even notice that (except for warning message from PG).
+      #
+      # To disable such behavior set:
+      #   client.async_autoreconnect = false
+      #
+      # or pass as new() hash argument:
+      #   PG::EM::Client.new database: 'bar', async_autoreconnect: false
+      #
+      # Otherwise nothing changes in PG::Connect API.
+      # See PG::Connect docs for arguments to above methods.
+      #
+      # *Warning:*
+      #
+      # +async_exec_prepared+ after +async_prepare+ should only be invoked on
+      # the *same* connection.
+      # If you are using connection pool, make sure to acquire single connection first.
+      #
+
+      attr_accessor :async_autoreconnect
+
+      module Watcher
+        def initialize(client, deferrable)
+          @client = client
+          @deferrable = deferrable
+        end
+
+        def notify_readable
+          @client.consume_input
+          return if @client.is_busy
+          detach
+          begin
+            result = @client.get_last_result
+          rescue Exception => e
+            @deferrable.fail(e)
+          else
+            @deferrable.succeed(result)
+          end
+        end
+      end
+
+      def initialize(*args)
+        @async_autoreconnect = true
+        if args.last.is_a? Hash
+          args.last.reject! do |key, value|
+            if key.to_s == 'async_autoreconnect'
+              @async_autoreconnect = !!value
+              true
+            end
+          end
+        end
+        super(*args)
+      end
+
+      %w(
+        exec          send_query
+        prepare       send_prepare
+        exec_prepared send_query_prepared
+          ).each_slice(2) do |name, send_name|
+
+        class_eval <<-EOD
+        def async_#{name}(*args, &blk)
+          begin
+            #{send_name}(*args)
+          rescue PG::Error => e
+            if self.status != PG::CONNECTION_OK && async_autoreconnect
+              reset
+              #{send_name}(*args)
+            else
+              raise e
+            end
+          end
+          df = ::EM::DefaultDeferrable.new
+          ::EM.watch(self.socket, Watcher, self, df).notify_readable = true
+          if block_given?
+            df.callback(&blk)
+            df.errback(&blk)
+          end
+          df
+        end
+        EOD
+
+        class_eval <<-EOD
+        def #{name}(*args, &blk)
+          if ::EM.reactor_running?
+            async_#{name}(*args, &blk)
+          else
+            super(*args, &blk)
+          end
+        end
+        EOD
+
+      end
+
+      alias_method :query, :exec
+      alias_method :async_query, :async_exec
+    end
+  end
+end

data/spec/em_client.rb

@@ -0,0 +1,57 @@
+$:.unshift "lib"
+require 'date'
+require 'eventmachine'
+require 'pg/em'
+
+describe PG::EM::Client do
+
+  it "should create simple table `foo`" do
+    @client.query('DROP TABLE IF EXISTS foo') do
+      @client.query('CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)') do
+        EM.stop
+      end
+    end
+  end
+
+  it "should populate foo with some data " do
+    EM::Iterator.new(@values).map(proc{ |(data, id), iter|
+      @client.query('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
+        iter.return(DateTime.parse(result[0]['cdate']))
+      end
+    }, proc{ |results|
+      @cdates.replace results
+      results.length.should == @values.length
+      results.each {|r| r.class.should == DateTime }
+      EM.stop
+    })
+  end
+
+  it "should read foo table with prepared statement" do
+    @client.prepare('get_foo', 'SELECT * FROM foo order by id') do
+      @client.exec_prepared('get_foo') do |result|
+        result.each_with_index do |row, i|
+          row['id'].to_i.should == i
+          DateTime.parse(row['cdate']).should == @cdates[i]
+          row['data'].should == @values[i][0]
+        end
+        EM.stop
+      end
+    end
+  end
+  
+  around(:each) do |testcase|
+    EM.run &testcase
+  end
+
+  before(:all) do
+    @cdates = []
+    @values = Array(('AA'..'ZZ').each_with_index)
+    @client = PG::EM::Client.new(dbname: 'test')
+    @client.query 'BEGIN TRANSACTION'
+  end
+
+  after(:all) do
+    @client.query 'ROLLBACK TRANSACTION'
+    @client.close
+  end
+end

data/spec/em_synchrony_client.rb

@@ -0,0 +1,54 @@
+$:.unshift "lib"
+require 'date'
+require 'em-synchrony'
+require 'em-synchrony/pg'
+
+describe PG::EM::Client do
+
+  it "should create simple table `foo`" do
+    @client.query('DROP TABLE IF EXISTS foo')
+    @client.query('CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)')
+    EM.stop
+  end
+
+  it "should populate foo with some data " do
+    results = @values.map do |(data, id)|
+      @client.query('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
+        DateTime.parse(result[0]['cdate'])
+      end
+    end
+    @cdates.replace results
+    results.length.should == @values.length
+    results.each {|r| r.class.should == DateTime }
+    EM.stop
+  end
+
+  it "should read foo table with prepared statement" do
+    @client.prepare('get_foo', 'SELECT * FROM foo order by id')
+    @client.exec_prepared('get_foo') do |result|
+      result.each_with_index do |row, i|
+        row['id'].to_i.should == i
+        DateTime.parse(row['cdate']).should == @cdates[i]
+        row['data'].should == @values[i][0]
+      end
+    end
+    EM.stop
+  end
+
+  around(:each) do |testcase|
+    EM.synchrony &testcase
+  end
+
+  before(:all) do
+    @cdates = []
+    @values = Array(('AA'..'ZZ').each_with_index)
+    @client = PG::EM::Client.new(dbname: 'test')
+    @client.query 'BEGIN TRANSACTION'
+  end
+
+  after(:all) do
+    @client.query 'ROLLBACK TRANSACTION'
+    @client.close
+  end
+
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: em-pg-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Rafal Michalski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: PostgreSQL asynchronous EventMachine client (ruby-pg) wrapper
+email: rafal@yeondir.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- BENCHMARKS.rdoc
+files:
+- BENCHMARKS.rdoc
+- README.rdoc
+- Rakefile
+- benchmarks/em_pg.rb
+- em-pg-client.gemspec
+- lib/em-synchrony/pg.rb
+- lib/pg/em.rb
+- spec/em_client.rb
+- spec/em_synchrony_client.rb
+homepage: http://github.com/royaltm/ruby-em-pg-client
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- em-pg-client
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- PostgreSQL server
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: EventMachine PostgreSQL client
+test_files:
+- spec/em_client.rb
+- spec/em_synchrony_client.rb