oldmoe-neverblock 0.1.3 → 0.1.4

data/lib/active_record/connection_adapters/neverblock_mysql_adapter.rb

@@ -37,7 +37,7 @@ class ActiveRecord::ConnectionAdapters::NeverBlockMysqlAdapter < ActiveRecord::C
   end
 
   def connect
-    @connection = ::NB::DB::PooledFiberedMysqlConnection.new(@connection_options.shift) do
+    @connection = ::NB::DB::PooledDBConnection.new(@connection_options.shift) do
       conn = ::NB::DB::FMysql.init
       encoding = @config[:encoding]
       if encoding

data/lib/active_record/connection_adapters/neverblock_postgresql_adapter.rb

@@ -28,47 +28,38 @@ class ActiveRecord::ConnectionAdapters::NeverBlockPostgreSQLAdapter < ActiveReco
       end
 
       def connect
-        size = @connection_parameters.shift
-        @connection = ::NB::DB::PooledFiberedPostgresConnection.new(@connection_parameters, size)
-
-        PGconn.translate_results = false if PGconn.respond_to?(:translate_results=)
-
-        # Ignore async_exec and async_query when using postgres-pr.
-        @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
-
-        # Use escape string syntax if available. We cannot do this lazily when encountering
-        # the first string, because that could then break any transactions in progress.
-        # See: http://www.postgresql.org/docs/current/static/runtime-config-compatible.html
-        # If PostgreSQL doesn't know the standard_conforming_strings parameter then it doesn't
-        # support escape string syntax. Don't override the inherited quoted_string_prefix.
-        NB.neverblock(false) do
-
-          @connection.begin_db_transaction
-          if supports_standard_conforming_strings?
-            self.class.instance_eval do
-              define_method(:quoted_string_prefix) { 'E' }
-            end
-          end
-
-          # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
-          # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
-          # should know about this but can't detect it there, so deal with it here.
-          money_precision = (postgresql_version >= 80300) ? 19 : 10
-          ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.module_eval(<<-end_eval)
-            def extract_precision(sql_type)
-              if sql_type =~ /^money$/
-                #{money_precision}
-              else
-                super
+        @connection = ::NB::DB::PooledFiberedPostgresConnection.new(@connection_parameters.shift) do
+          conn = PGconn.connect(*@connection_parameters)
+          PGconn.translate_results = false if PGconn.respond_to?(:translate_results=)
+          # Ignore async_exec and async_query when using postgres-pr.
+          @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
+          # Use escape string syntax if available. We cannot do this lazily when encountering
+          # the first string, because that could then break any transactions in progress.
+          # See: http://www.postgresql.org/docs/current/static/runtime-config-compatible.html
+          # If PostgreSQL doesn't know the standard_conforming_strings parameter then it doesn't
+          # support escape string syntax. Don't override the inherited quoted_string_prefix.
+          NB.neverblock(false) do
+            if supports_standard_conforming_strings?
+              self.class.instance_eval do
+                define_method(:quoted_string_prefix) { 'E' }
               end
             end
-          end_eval
-
-          configure_connection
-          @connection.commit_db_transaction
-
+            # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
+            # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
+            # should know about this but can't detect it there, so deal with it here.
+            money_precision = (postgresql_version >= 80300) ? 19 : 10
+            ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.module_eval(<<-end_eval)
+              def extract_precision(sql_type)
+                if sql_type =~ /^money$/
+                  #{money_precision}
+                else
+                  super
+                end
+              end
+            end_eval
+            #configure_connection
+          end
         end
-
       end
 
       # Close then reopen the connection.

data/lib/never_block/db/fibered_db_connection.rb

@@ -0,0 +1,57 @@
+module NeverBlock
+  module DB
+    module FiberedDBConnection
+      # Attaches the connection socket to an event loop.
+      # Currently only supports EM, but Rev support will be
+      # completed soon.
+      def register_with_event_loop(loop)
+        @fd = socket
+        @io = IO.new(socket)
+        if loop == :em
+          if EM.reactor_running?
+            @em_connection = EM::attach(@io,EMConnectionHandler,self)
+          else
+            raise "REACTOR NOT RUNNING YA ZALAMA"
+          end
+        elsif loop.class.name == "REV::Loop"
+          loop.attach(RevConnectionHandler.new(@fd))
+        else
+          raise "could not register with the event loop"
+        end
+        @loop = loop
+      end  
+
+      # Unattaches the connection socket from the event loop
+      def unregister_from_event_loop
+        if @loop == :em
+          @em_connection.detach
+        else
+          raise NotImplementedError.new("unregister_from_event_loop not implemented for #{@loop}")
+        end
+      end
+           
+      # The callback, this is called whenever
+      # there is data available at the socket
+      def resume_command
+        #protection against being called several times
+        if @fiber
+          f = @fiber
+          @fiber = nil
+          f.resume
+        else
+          unregister_from_event_loop
+        end
+      end
+      
+    end
+    
+    module EMConnectionHandler
+      def initialize connection
+        @db_connection = connection
+      end
+      def notify_readable
+        @db_connection.resume_command
+      end
+    end
+  end
+end

data/lib/never_block/db/fibered_mysql_connection.rb

@@ -1,9 +1,9 @@
-require 'mysql'
+require 'mysqlplus'
 
 module NeverBlock
 
   module DB
-    # A modified postgres connection driver
+    # A modified mysql connection driver
     # builds on the original pg driver.
     # This driver is able to register the socket
     # at a certain backend (EM or Rev)
@@ -12,85 +12,48 @@ module NeverBlock
     # it will be done in async mode and the fiber
     # will yield
 	  class FiberedMysqlConnection < Mysql	      
-      # needed to access the sockect by the event loop
-      attr_reader :fd, :io
-        
-      # Creates a new mysql connection, sets it
-      # to nonblocking and wraps the descriptor in an IO
-      # object.
-	    def real_connect(*args)
-        super(*args)
-        @fd = socket
-        @io = IO.new(socket)
-      end
-      #alias :real_connect :initialize
-      #alias :connect :initialize
+                
+      include FiberedDBConnection
         
       # Assuming the use of NeverBlock fiber extensions and that the exec is run in
       # the context of a fiber. One that have the value :neverblock set to true.
       # All neverblock IO classes check this value, setting it to false will force
       # the execution in a blocking way.
       def query(sql)
-        if Fiber.respond_to? :current and Fiber.current[:neverblock]		      
-          send_query sql
-          @fiber = Fiber.current		      
-          Fiber.yield 
-        else		      
-          super(sql)
-        end		
-      end
-      
-      # Attaches the connection socket to an event loop.
-      # Currently only supports EM, but Rev support will be
-      # completed soon.
-      def register_with_event_loop(loop)
-        if loop == :em
-          unless EM.respond_to?(:attach)
-            puts "invalide EM version, please download the modified gem from: (http://github.com/riham/eventmachine)"
-            exit
+        begin
+          if Fiber.respond_to? :current and Fiber.current[:neverblock]		      
+            send_query sql
+            @fiber = Fiber.current		      
+            Fiber.yield
+            get_result 
+          else		      
+            super(sql)
           end
-          if EM.reactor_running?
-            @em_connection = EM::attach(@io,EMConnectionHandler,self)
-          else
-            raise "REACTOR NOT RUNNING YA ZALAMA"
-          end 
-        elsif loop.class.name == "REV::Loop"
-          loop.attach(RevConnectionHandler.new(socket))
-        else
-          raise "could not register with the event loop"
-        end
-        @loop = loop
-      end  
-
-      # Unattaches the connection socket from the event loop
-      def unregister_from_event_loop
-        if @loop == :em
-          @em_connection.unattach(false)
-        else
-          raise NotImplementedError.new("unregister_from_event_loop not implemented for #{@loop}")
-        end
+        rescue Exception => e
+          if error = ['not connected', 'gone away', 'Lost connection'].detect{|msg| e.message.include? msg}
+            stop
+            connect
+          end
+          raise e
+        end		
       end
 
-      # The callback, this is called whenever
-      # there is data available at the socket
-      def process_command
-        @fiber.resume get_result
-      end
+      alias :exec :query
       
-    end #FiberedPostgresConnection 
-    
-    # A connection handler for EM
-    # More to follow.
-    module EMConnectionHandler
-      def initialize connection
-        @connection = connection
+      # stop the connection and deattach from the event loop
+      def stop
+        unregister_from_event_loop
       end
-      def notify_readable
-        @connection.process_command
+      
+      # reconnect and attach to the event loop
+      def connect
+        super
+        register_with_event_loop(@loop)    
       end
-    end
+            
+    end #FiberedMySQLConnection 
 
-    end #DB
+  end #DB
 
 end #NeverBlock
 

data/lib/never_block/db/fibered_postgres_connection.rb

@@ -3,6 +3,7 @@ require 'pg'
 module NeverBlock
 
   module DB
+  
     # A modified postgres connection driver
     # builds on the original pg driver.
     # This driver is able to register the socket
@@ -12,95 +13,50 @@ module NeverBlock
     # it will be done in async mode and the fiber
     # will yield
 	  class FiberedPostgresConnection < PGconn	      
-      # needed to access the sockect by the event loop
-      attr_reader :fd, :io
-        
-      # Creates a new postgresql connection, sets it
-      # to nonblocking and wraps the descriptor in an IO
-      # object.
-	    def initialize(*args)
-        super(*args)
-        @fd = socket
-        @io = IO.new(socket)
-        #setnonblocking(true)
-      end
-        
+              
+      include FiberedDBConnection
+
       # Assuming the use of NeverBlock fiber extensions and that the exec is run in
       # the context of a fiber. One that have the value :neverblock set to true.
       # All neverblock IO classes check this value, setting it to false will force
       # the execution in a blocking way.
       def exec(sql)
-        if Fiber.respond_to? :current and Fiber.current[:neverblock]		      
-          self.send_query sql
-          @fiber = Fiber.current		      
-          Fiber.yield 
-        else		      
-          super(sql)
-        end		
-      end
-      
-      # Attaches the connection socket to an event loop.
-      # Currently only supports EM, but Rev support will be
-      # completed soon.
-      def register_with_event_loop(loop)
-        if loop == :em
-          unless EM.respond_to?(:attach)
-            puts "invalide EM version, please download the modified gem from: (http://github.com/riham/eventmachine)"
-            exit
+        begin
+          if Fiber.respond_to? :current and Fiber.current[:neverblock]		      
+            send_query sql
+            @fiber = Fiber.current		      
+            Fiber.yield 
+            while is_busy
+              consume_input
+              Fiber.yield if is_busy
+            end
+            res, data = 0, []
+            while res != nil
+              res = self.get_result
+              data << res unless res.nil?
+            end
+            data.last          
+          else		      
+            super(sql)
           end
-          if EM.reactor_running?
-             @em_connection = EM::attach(@io,EMConnectionHandler,self)
-          else
-            raise "REACTOR NOT RUNNING YA ZALAMA"
-          end 
-        elsif loop.class.name == "REV::Loop"
-          loop.attach(RevConnectionHandler.new(socket))
-        else
-          raise "could not register with the event loop"
-        end
-        @loop = loop
+        rescue Exception => e
+          reset if e.message.include? "not connected"
+          raise e
+        end		
       end
 
-      # Unattaches the connection socket from the event loop
-      # As with register, EM is the only one supported for now
-      def unregister_from_event_loop
-        if @loop == :em
-          @em_connection.unattach(false)
-        else
-          raise NotImplementedError.new("unregister_from_event_loop not implemented for #{@loop}")
-        end
-      end
+      alias :query :exec
 
-      # The callback, this is called whenever
-      # there is data available at the socket
-      def process_command
-        # make sure all commands are sent
-        # before attempting to read
-        #return unless self.flush
-        self.consume_input
-        unless is_busy		
-          res, data = 0, []
-          while res != nil
-            res = self.get_result
-            data << res unless res.nil?
-          end
-          #let the fiber continue its work		      
-          @fiber.resume(data.last)
-        end
+      # reset the connection
+      # and reattach to the
+      # event loop
+      def reset
+        unregister_from_event_loop
+        super
+        register_with_event_loop(@loop)    
       end
-      
+            
     end #FiberedPostgresConnection 
-    
-    # A connection handler for EM
-    # More to follow.
-    module EMConnectionHandler
-      def initialize connection
-        @connection = connection
-      end
-      def notify_readable
-        @connection.process_command
-      end
-    end
 
     end #DB
 

data/lib/never_block/db/{pooled_fibered_mysql_connection.rb → pooled_db_connection.rb}

@@ -1,19 +1,15 @@
 module NeverBlock
   module DB
-    # A pooled postgres connection class. 
-    # This class represents a proxy interface
-    # to a connection pool of fibered postgresql
-    # connections.
-    class PooledFiberedMysqlConnection
-
-      # Requires a hash or an array with connection parameters
+    # a proxy for pooled fibered connections
+    class PooledDBConnection
+      # Requires a block with connection parameters
       # and a pool size (defaults to 4)
       def initialize(size=4, &block)
         @pool = NB::Pool::FiberedConnectionPool.new(:size=>size, :eager=>true) do
           yield
         end
       end
-      
+            
       # A proxy for the connection's query method
       # quries the pool to get a connection first
       def query(query)
@@ -21,6 +17,8 @@ module NeverBlock
           conn.query(query)
         end
       end
+
+      alias :exec :query
       
       # This method must be called for transactions to work correctly.
       # One cannot just send "begin" as you never know which connection
@@ -51,7 +49,6 @@ module NeverBlock
       #close all connections and remove them from the event loop
       def close
         @pool.all_connections do |conn|
-          conn.unregister_from_event_loop
           conn.close
         end
       end
@@ -68,10 +65,7 @@ module NeverBlock
         @pool.hold do |conn|
           conn.respond_to?(method)
         end        
-      end
-            
+      end      
     end
   end
 end
-
-NeverBlock::DB::PFMysql = NeverBlock::DB::PooledFiberedMysqlConnection

data/lib/never_block/frameworks/rails.rb

@@ -1,6 +1,4 @@
 require 'neverblock' unless defined?(NeverBlock)
-#require 'actionpack'
-#require 'action_controller'
 
 # Rails tries to protect dispatched actions
 # by wrapping them in a synchronized code
@@ -9,29 +7,59 @@ require 'neverblock' unless defined?(NeverBlock)
 # transform it (without it knowing) to
 # something more subtle
 
-
-=begin
-class ActionController::Dispatcher
-
-  # let's show this guard who is
-  # the man of the house
-  @@guard = Object.new
-
-  # now you synchronize
-  def @@guard.synchronize(&block)
+require 'thread'
+# now you synchronize
+class Mutex
+  def synchronize(&block)
     # now you don't!
     block.call
   end
 end
-=end
 
+require 'action_controller'
+class ActionController::Base
 
-require 'thread'
+  # Mark some actions to execute in a blocking manner overriding the default
+  # settings.
+  # Example:
+  #   class UsersController < ApplicationController
+  #     .
+  #     allowblock :index
+  #     .
+  #   end
+  def self.allowblock(*actions)
+    actions.each do |action|
+      class_eval <<-"end_eval"
+        def allowblock_#{action}
+          status = Fiber.current[:neverblock]
+          Fiber.current[:neverblock] = false
+          yield
+          Fiber.current[:neverblock] = status
+        end
+        around_filter :allowblock_#{action}, :only => [:#{action}]
+      end_eval
+    end
+  end
 
-# now you synchronize
-class Mutex
-  def synchronize(&block)
-    # now you don't!
-    block.call
+  # Mark some actions to execute in a non-blocking manner overriding the default
+  # settings.
+  # Example:
+  #   class UsersController < ApplicationController
+  #     .
+  #     allowblock :index
+  #     .
+  #   end
+  def self.neverblock(*actions)
+    actions.each do |action|
+      class_eval <<-"end_eval"
+        def neverblock_#{action}
+          status = Fiber.current[:neverblock]
+          Fiber.current[:neverblock] = true
+          yield
+          Fiber.current[:neverblock] = status
+        end
+        around_filter :allowblock_#{action}, :only => [:#{action}]
+      end_eval
+    end
   end
 end

data/lib/never_block/pool/fiber_pool.rb

@@ -31,46 +31,45 @@ module NeverBlock
     #   end
     # end
     #
-	  class FiberPool
+    class FiberPool
 
-	    # gives access to the currently free fibers
-		  attr_reader :fibers
+      # gives access to the currently free fibers
+      attr_reader :fibers
 
-		  # Prepare a list of fibers 
-		  # that are able to run different
-		  # blocks of code every time
-		  # once a fiber is done with its block
-		  # it attempts to fetch another one
-		  # from the queue. 
-		  def initialize(count = 50)
-			  @fibers,@queue = [],[]
-			  count.times do |i| 
-				  fiber = Fiber.new do |block|
-					  loop do
-						  block.call
-						  unless @queue.empty?
-							  block = @queue.shift
-						  else
-							  block = Fiber.yield @fibers << Fiber.current
-						  end
-					  end
-				  end
-				  fiber[:neverblock] = true
-				  @fibers << fiber
-			  end 
-		  end
+      # Prepare a list of fibers that are able to run different blocks of code
+      # every time. Once a fiber is done with its block, it attempts to fetch
+      # another one from the queue
+      def initialize(count = 50)
+        @fibers,@queue = [],[]
+        count.times do |i|
+          fiber = Fiber.new do |block|
+            loop do
+              block.call
+              unless @queue.empty?
+                block = @queue.shift
+              else
+                block = Fiber.yield @fibers << Fiber.current
+              end
+            end
+          end
+          fiber[:neverblock] = true
+          @fibers << fiber
+        end
+      end
+
+      # If there is an available fiber use it, otherwise, leave it to linger
+      # in a queue
+      def spawn(evented = true, &block)
+        if fiber = @fibers.shift
+          fiber[:neverblock] = evented
+          fiber.resume(block)
+        else
+          @queue << block
+        end
+        self # we are keen on hiding our queue
+      end
+
+    end # FiberPool
+  end # Pool
+end # NeverBlock
 
-		  # If there is an available fiber
-		  # use it, otherwise, leave it to linger in a queue
-		  def spawn(evented = true, &block)
-			  if fiber = @fibers.shift
-			    fiber[:neverblock] = evented
-				  fiber.resume(block)
-			  else
-				  @queue << block
-			  end
-			  self # we are keen on hiding our queue 
-		  end
-	  end
-	end
-end

data/lib/never_block/pool/fibered_connection_pool.rb

@@ -25,19 +25,28 @@ module NeverBlock
     # end
     # 32.times do
     #   Fiber.new do
-    #     conn = pool.hold # hold will pause the fiber until a connection is available
-    #     conn.execute('something') # you can use the connection normally now 
+    #     # acquire a connection from the pool
+    #     pool.hold do |conn|
+    #       conn.execute('something') # you can use the connection normally now
+    #     end
     #   end.resume
     # end
     # 
-    # The pool has support for transactions, just pass true to the pool#hold method
-    # and the connection will not be released after the block is finished
+    # The pool has support for transactions, just pass true to the
+    # pool#hold method and the connection will not be released after the block
+    # is finished
     # It is the responsibility of client code to release the connection
 		class FiberedConnectionPool
-       
-      # initialize the connection pool
-      # using the supplied proc to create the connections
-      # you can choose to start them eagerly or lazily (lazy by default)     
+
+      attr_reader :size
+
+      # initialize the connection pool using the supplied proc to create
+      # the connections
+      # You can choose to start them eagerly or lazily (lazy by default)
+      # Available options are
+      #   :size => the maximum number of connections to be created in the pool
+      #   :eager => (true|false) indicates whether connections should be
+      #             created initially or when need
 			def initialize(options = {}, &block)
 				@connections, @busy_connections, @queue = [], {},[]
 				@connection_proc = block
@@ -45,16 +54,13 @@ module NeverBlock
 				if options[:eager]
 				  @size.times do
 				    @connections << @connection_proc.call
-				  end  
+				  end
 				end
 			end
 
-      # If a connection is available,
-      # pass it to the block, otherwise 
-      # pass the fiber to the queue
-      # till a connection is available
-      # when done with a connection
-      # try to porcess other fibers in the queue
+      # If a connection is available, pass it to the block, otherwise pass
+      # the fiber to the queue till a connection is available
+      # when done with a connection try to porcess other fibers in the queue
       # before releasing the connection
       # if inside a transaction, don't release the fiber
 			def hold(transactional = false)
@@ -67,7 +73,7 @@ module NeverBlock
 			    yield conn
 			  ensure
 			    release(fiber, conn) unless transactional
-					process_queue 
+					process_queue
 			  end
 			end
 
@@ -106,7 +112,7 @@ module NeverBlock
 					fiber = @queue.shift
 					# What is really happening here?
 					# we are resuming a fiber from within
-					# another, should we call transfer insted?
+					# another, should we call transfer instead?
 					fiber.resume @busy_connections[fiber] = @connections.shift
 				end
 			end

data/lib/never_block/servers/thin.rb

@@ -4,10 +4,8 @@ require 'thin'
 
 module Thin
   
-  # Patch the thin server to use 
-  # NeverBlock::Pool::FiberPool
-  # to be able to wrap requests
-  # in fibers
+  # Patch the thin server to use NeverBlock::Pool::FiberPool to be able to
+  # wrap requests in fibers
   class Server
 
     DEFAULT_FIBER_POOL_SIZE = 20
@@ -18,17 +16,14 @@ module Thin
 
   end # Server
 
-  # A request is processed by wrapping it
-  # in a fiber from the fiber pool. If all
-  # the fibers are busy the request will
-  # wait in a queue to be picked up later.
-  # Meanwhile, the server will still be
-  # processing requests
+  # A request is processed by wrapping it in a fiber from the fiber pool.
+  # If all the fibers are busy the request will wait in a queue to be picked up
+  # later. Meanwhile, the server will still be processing requests
   class Connection < EventMachine::Connection
 
     def process
         @request.threaded = false
-        @backend.server.fiber_pool.spawn{post_process(pre_process)}
+        @backend.server.fiber_pool.spawn {post_process(pre_process)}
     end
     
   end # Connection

data/lib/neverblock-mysql.rb

@@ -1,4 +1,5 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
 require 'neverblock'
+require 'never_block/db/fibered_db_connection'
 require 'never_block/db/fibered_mysql_connection'
-require 'never_block/db/pooled_fibered_mysql_connection'
+require 'never_block/db/pooled_db_connection'

data/neverblock.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "neverblock"
-  s.version  = "0.1.3"
-  s.date     = "2008-09-04"
+  s.version  = "0.1.4"
+  s.date     = "2008-09-20"
   s.summary  = "Utilities for non-blocking stack components"
   s.email    = "oldmoe@gmail.com"
   s.homepage = "http://github.com/oldmoe/neverblock"
@@ -23,14 +23,15 @@ Gem::Specification.new do |s|
     "lib/never_block/servers/thin.rb",
     "lib/never_block/servers/mongrel.rb",
     "lib/never_block/db/fibered_postgres_connection.rb",
-    "lib/never_block/db/pooled_fibered_postgres_connection.rb",
+    "lib/never_block/db/pooled_db_connection.rb",
     "lib/never_block/db/fibered_mysql_connection.rb",
-    "lib/never_block/db/pooled_fibered_mysql_connection.rb",
+    "lib/never_block/db/fibered_db_connection.rb",
     "lib/active_record/connection_adapters/neverblock_postgresql_adapter.rb",
     "lib/active_record/connection_adapters/neverblock_mysql_adapter.rb"
   ]
   s.rdoc_options = ["--main", "README"]
   s.extra_rdoc_files = ["README"]
+  s.add_dependency('eventmachine', '>= 0.12.2')
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: oldmoe-neverblock
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Muhammad A. Ali
@@ -11,10 +11,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-04 00:00:00 -07:00
+date: 2008-09-20 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.2
+    version: 
 description: NeverBlock is a collection of classes and modules that help you write evented non-blocking applications in a seemingly blocking mannner.
 email: oldmoe@gmail.com
 executables: []
@@ -38,9 +46,9 @@ files:
 - lib/never_block/servers/thin.rb
 - lib/never_block/servers/mongrel.rb
 - lib/never_block/db/fibered_postgres_connection.rb
-- lib/never_block/db/pooled_fibered_postgres_connection.rb
+- lib/never_block/db/pooled_db_connection.rb
 - lib/never_block/db/fibered_mysql_connection.rb
-- lib/never_block/db/pooled_fibered_mysql_connection.rb
+- lib/never_block/db/fibered_db_connection.rb
 - lib/active_record/connection_adapters/neverblock_postgresql_adapter.rb
 - lib/active_record/connection_adapters/neverblock_mysql_adapter.rb
 has_rdoc: true

data/lib/never_block/db/pooled_fibered_postgres_connection.rb

@@ -1,81 +0,0 @@
-module NeverBlock
-  module DB
-    # A pooled postgres connection class. 
-    # This class represents a proxy interface
-    # to a connection pool of fibered postgresql
-    # connections.
-    class PooledFiberedPostgresConnection
-
-      # Requires a hash or an array with connection parameters
-      # and a pool size (defaults to 4)
-      def initialize(conn_params, size=4)
-        @pool = NB::Pool::FiberedConnectionPool.new(:size=>size, :eager=>true) do
-          conn = NB::DB::FPGconn.new(*conn_params) if conn_params.is_a? Array
-          conn = NB::DB::FPGconn.new(conn_params) if conn_params.is_a? Hash          
-	        conn.register_with_event_loop(:em)
-          conn          
-        end
-      end
-      
-      # A proxy for the connection's exec method
-      # quries the pool to get a connection first
-      def exec(query)
-        @pool.hold do |conn|
-          conn.exec(query)
-        end
-      end
-      
-      # This method must be called for transactions to work correctly.
-      # One cannot just send "begin" as you never know which connection
-      # will be available next. This method ensures you get the same connection
-      # while in a transaction.
-      def begin_db_transaction
-        @pool.hold(true) do |conn|
-          conn.exec("begin")
-        end
-      end
-      
-      # see =begin_db_transaction
-      def rollback_db_transaction
-        @pool.hold do |conn|
-          conn.exec("rollback")
-          @pool.release(Fiber.current,conn)
-        end
-      end
-      
-      # see =begin_db_transaction
-      def commit_db_transaction
-        @pool.hold do |conn|
-          conn.exec("commit")
-          @pool.release(Fiber.current,conn)
-        end
-      end
-
-      #close all connections and remove them from the event loop
-      def close
-        @pool.all_connections do |conn|
-          conn.unregister_from_event_loop
-          conn.close
-        end
-      end
-      
-      # Pass unknown methods to the connection
-      def method_missing(method, *args)
-        @pool.hold do |conn|
-          conn.send(method, *args)
-        end        
-      end
-
-      # Pass method queries to the connection
-      def respond_to?(method)
-        @pool.hold do |conn|
-          conn.respond_to?(method)
-        end        
-      end
-            
-    end
-  end
-end
-
-NB::DB::PFPGconn = NeverBlock::DB::FiberedPostgresConnection
-