em-pg 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+group :test do
+  gem "minitest"
+  gem "minitest-reporters"
+  gem "debugger"
+  gem "minitest-em-sync"
+end
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    em-pg (0.1.0)
+      eventmachine (>= 0.12)
+      pg (>= 0.14)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ansi (1.4.3)
+    builder (3.1.4)
+    columnize (0.3.6)
+    debugger (1.2.2)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.5)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.5)
+    eventmachine (1.0.0)
+    hashie (1.2.0)
+    minitest (4.1.0)
+    minitest-em-sync (0.1.0)
+      eventmachine (>= 0.12)
+    minitest-reporters (0.12.0)
+      ansi
+      builder
+      minitest (>= 2.12, < 5.0)
+      powerbar
+    pg (0.14.1)
+    powerbar (1.0.11)
+      ansi (~> 1.4.0)
+      hashie (>= 1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  debugger
+  em-pg!
+  minitest
+  minitest-em-sync
+  minitest-reporters

data/README.md

@@ -0,0 +1,91 @@
+EM::PG
+======
+
+One more EventMachine wrapper for Postgresql [pg-lib](https://github.com/ged/ruby-pg).
+
+Features
+--------
+
+* Fully async including connect and right usage of #busy and #consume_input;
+* All results are standard deferrable objects;
+* Distinct exceptions hierarchy;
+* Wrapper for [Green](https://github.com/prepor/green) and adapter fot [Sequel](http://sequel.rubyforge.org/).
+
+Usage
+-----
+
+```ruby
+gem "em-pg"
+```
+
+```ruby
+require "em/pg"
+
+EM.run do
+  db = EM::PG.new host: "localhost", port: 5432, dbname: "test", user: "postgres", password: "postgres"
+  db.callback do
+    q = db.send_query "select 1"
+	q.callback do |res|
+	  puts "RESULT: #{res.inspect}"
+	  EM.stop
+	end
+	q.errback do |e|
+	  raise e
+	end
+  end
+  
+  db.errback do |e|
+    raise e
+  end
+end
+```
+
+To all errbacks pass one argument, instance of EM::PG::Error. So it easy to write common handlers and wrappers for something like EM-Synchrony and Green.
+
+### Supported methods
+
+* `send_query`
+* `send_prepare`
+* `send_query_prepared`
+* `send_describe_prepared`
+* `send_describe_portal`
+
+All have same semantics as in pg-lib, but result is a Deferrable object
+
+### Disconnects
+
+On disconnect all current queries will be failed with exception DisconnectError. You also can pass :on_disconnect callback with options, wich will be called before queries errbacks.
+
+EM::PG doesn't have reconnect strategy, you should handle disconnects by youself.
+
+### Logging
+
+You can pass :logger option or set `EM::PG.logger` for all instances.
+
+Exceptions
+----------
+
+```
+ EM::PG::Error
+   ConnectionRefusedError
+   DisconnectError
+   BadStateError
+   UnexpectedStateError
+     BadConnectionStatusError
+	 BadPollStatusError
+   PGError
+```
+
+* ConnectionRefusedError - can't connect. Have field `.message` with reason;
+* DisconnectError - connection disconnected. Will be raised on all uncompleted queries;
+* BadStateError - you try do something while a wrong state. For example send query on not connected client;
+* UnexpectedStateError - something gone wrong :(
+* PGError - original PG exceptions was raised. Have field `.original`.
+
+See also
+--------
+
+* [em-pg-client](https://github.com/royaltm/ruby-em-pg-client) - good wrapper around pg-lib with reconnects.
+* [em-postgres](https://github.com/jtoy/em-postgres)
+* [em-postgresql-sequel](https://github.com/jzimmek/em-postgresql-sequel)
+

data/Rakefile

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/em/pg.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :spec
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end

data/em-pg.gemspec

@@ -0,0 +1,26 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'em-pg'
+  s.version = '0.1.0'
+  s.date = '2013-01-28'
+  s.summary = 'Async PostgreSQL client API for Ruby/EventMachine'
+  s.email = "ceo@prepor.ru"
+  s.homepage = "http://github.com/prepor/em-postgres"
+  s.description = 'Async PostgreSQL client API for Ruby/EventMachine'
+  s.has_rdoc = false
+  s.authors = ["Andrew Rudenko"]
+  s.add_dependency('eventmachine', '>= 0.12')
+  s.add_dependency('pg', '>= 0.14')
+
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    Gemfile.lock
+    README.md
+    Rakefile
+    em-pg.gemspec
+    lib/em/pg.rb
+    spec/em/pg_spec.rb
+    spec/spec_helper.rb
+  ]
+  # = MANIFEST =
+end

data/lib/em/pg.rb

@@ -0,0 +1,220 @@
+require 'eventmachine'
+require 'pg'
+require 'logger'
+
+module EM
+  class PG
+    VERSION = '0.1.0'
+    include EM::Deferrable
+
+    class Error < RuntimeError
+      def initialize(params = {})
+        params.each { |k, v| self.send("#{k}=", v) }
+      end
+    end
+    class ConnectionRefusedError < Error
+      attr_accessor :message
+    end
+    class DisconnectError < Error; end
+    class BadStateError < Error
+      attr_accessor :state
+    end
+    class UnexpectedStateError < Error; end
+    class BadConnectionStatusError < UnexpectedStateError; end
+    class BadPollStatusError < UnexpectedStateError; end
+    class PGError < Error
+      attr_accessor :original
+    end
+
+    class Watcher < EM::Connection
+      attr_accessor :postgres
+      def initialize(postgres)
+        @postgres = postgres
+      end
+
+      def notify_readable
+        @postgres.handle
+      end
+
+      def notify_writable
+        self.notify_writable = false
+        @postgres.handle
+      end
+
+      def unbind
+        @postgres.unbind
+      end
+
+    end
+
+
+    class Query
+      include EM::Deferrable
+      attr_accessor :method, :args
+      def initialize(method, args)
+        @method, @args = method, args
+      end
+    end
+
+    class << self
+      attr_accessor :logger
+    end
+    self.logger = Logger.new(STDOUT)
+
+    attr_accessor :pg, :conn, :opts, :state, :logger, :watcher, :on_disconnect
+    def initialize(opts)
+      opts = opts.dup
+      @logger = opts.delete(:logger) || EM::Postgres.logger
+      @on_disconnect = opts.delete(:on_disconnect)
+      @opts = opts
+      @state = :connecting
+
+      @pg = ::PG::Connection.connect_start(@opts)
+      @queue = []
+
+      @watcher = EM.watch(@pg.socket, Watcher, self)
+      @watcher.notify_readable = true
+      check_connect
+    end
+
+    def handle
+      case @state
+      when :connecting
+        check_connect
+      when :waiting
+        consume_result do |res|
+          result_for_query res
+        end
+      else # try check result, may be it close-message
+        consume_result do |res|
+          if res.is_a? Exception
+            unbind res
+          else
+            error "Result in unexpected state #{@state}: #{res.inspect}"
+          end
+        end
+      end
+    end
+
+    def check_connect
+      status = @pg.connect_poll
+      case status
+      when ::PG::PGRES_POLLING_OK
+        if pg.status == ::PG::CONNECTION_OK
+          connected
+        elsif pg.status == ::PG::CONNECTION_BAD
+          connection_refused
+        else
+          raise BadConnectionStatusError.new
+        end
+      when ::PG::PGRES_POLLING_READING
+      when ::PG::PGRES_POLLING_WRITING
+        @watcher.notify_writable = true
+      when ::PG::PGRES_POLLING_FAILED
+        @watcher.detach
+        connection_refused
+      else
+        raise BadPollStatsError.new
+      end
+    end
+
+    [:send_query, :send_prepare, :send_query_prepared, :send_describe_prepared, :send_describe_portal].each do |m|
+      define_method(m) do |*args|
+        make_query(m, *args)
+      end
+    end
+
+    def make_query(m, *args)
+      q = Query.new m, args
+      case @state
+      when :waiting
+        add_to_queue q
+      when :connected
+        run_query! q
+      else
+        q.fail BadStateError.new(state: @state)
+      end
+      q
+    end
+
+    def add_to_queue(query)
+      @queue << query
+    end
+
+    def run_query!(q)
+      @current_query = q
+      @state = :waiting
+      debug(["EM::PG", q.method, q.args])
+      @pg.send(q.method, *q.args)
+    end
+
+    def try_next_from_queue
+      q = @queue.shift
+      if q
+        run_query! q
+      end
+    end
+
+    def consume_result(&clb)
+      begin
+        @pg.consume_input # can raise exceptins
+        if @pg.is_busy
+        else
+          clb.call @pg.get_last_result # can raise exceptions
+        end
+      rescue ::PG::Error => e
+        clb.call PGError.new(original: e)
+      end
+    end
+
+    def result_for_query(res)
+      @state = :connected
+      q = @current_query
+      @current_query = nil
+      if res.is_a? Exception
+        q.fail res
+      else
+        q.succeed res
+      end
+      try_next_from_queue
+    end
+
+    def connected
+      @state = :connected
+      succeed :connected
+    end
+
+    def connection_refused
+      @state = :connection_refused
+      logger.error [:connection_refused, @pg.error_message]
+      fail ConnectionRefusedError.new(message: @pg.error_message)
+    end
+
+    def unbind(reason = nil)
+      return if @state == :disconnected
+      logger.error [:disconnected, reason]
+      @state = :disconnected
+      @watcher.detach
+      @on_disconnect.call if @on_disconnect
+      fail_queries DisconnectError.new
+    end
+
+    def close
+      @state = :closed
+      @watcher.detach
+      @pg.finish
+      fail_queries :closed
+    end
+
+    def fail_queries(exc)
+      @current_query.fail exc if @current_query
+      @queue.each { |q| q.fail exc }
+    end
+
+    [:trace, :debug, :info, :warn, :error, :fatal].each do |m|
+      define_method(m) do |*args, &blk|
+        logger.send(m, *args, &blk)
+      end
+    end
+  end
+end

data/spec/em/pg_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+describe EM::PG do
+  let(:db_options) do
+    {}
+  end
+  let(:db) do
+    EM::PG.new(DB_CONFIG.merge(db_options)).tap { |o| sync o }
+  end
+
+  include Minitest::EMSync
+
+  it "should invoke errback on connection failure" do
+    conn = EM::PG.new(DB_CONFIG.merge user: "unexist")
+    proc { sync conn }.must_raise EM::PG::ConnectionRefusedError
+  end
+
+  describe "with on_disconnect" do
+    let(:m) { EM::DefaultDeferrable.new }
+
+    let(:db_options) do
+      { on_disconnect: proc { m.succeed } }
+    end
+
+    it "should invoke on_disconnect" do
+      db
+      EM.next_tick { db.unbind } # don't known how to emulate real disconnect
+      sync m
+    end
+  end
+
+  it "should fail current queries on disconnect" do
+    q1 = db.send_query("select pg_sleep(10);")
+    q2 = db.send_query("select pg_sleep(10);")
+    EM.next_tick { db.unbind }
+    proc { sync q1 }.must_raise EM::PG::DisconnectError
+    proc { sync q2 }.must_raise EM::PG::DisconnectError
+  end
+
+  describe "successful connection" do
+    after do
+      db.close
+    end
+
+    it "should create a new connection" do
+      db.state.must_equal :connected
+    end
+
+    it "should execute sql" do
+      query = db.send_query("select 1;")
+      res = sync query
+      res.first["?column?"].must_equal "1"
+    end
+
+    it "allow custom error callbacks for each query" do
+      query = db.send_query("select 1 from")
+      proc { sync query }.must_raise EM::PG::PGError
+    end
+
+    it "queue up large amount of queries and execute them in order" do
+      results = []
+      m = EM::DefaultDeferrable.new
+      100.times do |i|
+        db.send_query("select #{i} AS x;").callback do |res|
+          results << res.first["x"].to_i
+          if results.size == 100
+            results.reduce(0, &:+).must_equal 100.times.reduce(0, &:+)
+            m.succeed
+          end
+        end
+      end
+      sync m
+    end
+
+    describe "not yet connected" do
+      let(:db) { EM::PG.new DB_CONFIG }
+      it "should fail query" do
+        q1 = db.send_query("select 1;")
+        proc { sync q1 }.must_raise EM::PG::BadStateError
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+
+require 'bundler/setup'
+
+require 'em/pg'
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/em_sync'
+
+logger = Logger.new nil
+
+DB_CONFIG = {
+  host: "localhost",
+  port: 5432,
+  dbname: "test",
+  user: "postgres",
+  password: "postgres",
+  logger: logger
+}
+
+MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: em-pg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Rudenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.14'
+description: Async PostgreSQL client API for Ruby/EventMachine
+email: ceo@prepor.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- em-pg.gemspec
+- lib/em/pg.rb
+- spec/em/pg_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/prepor/em-postgres
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Async PostgreSQL client API for Ruby/EventMachine
+test_files: []