espace-neverblock 0.1.4 → 0.1.5

data/lib/active_record/connection_adapters/neverblock_mysql_adapter.rb

@@ -11,50 +11,38 @@ class ActiveRecord::ConnectionAdapters::NeverBlockMysqlAdapter < ActiveRecord::C
   end
 
   def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-    begin_db_transaction
     super sql, name
     id_value || @connection.insert_id
-    commit_db_transaction
   end
 
   def update_sql(sql, name = nil) #:nodoc:
-    begin_db_transaction
     super
     @connection.affected_rows
-    commit_db_transaction
-  end
-
-  def begin_db_transaction
-    @connection.begin_db_transaction
-  end
-  
-  def commit_db_transaction
-    @connection.commit_db_transaction
-  end
-
-  def rollback_db_transaction
-    @connection.rollback_db_transaction
   end
 
   def connect
-    @connection = ::NB::DB::PooledFiberedMysqlConnection.new(@connection_options.shift) do
-      conn = ::NB::DB::FMysql.init
-      encoding = @config[:encoding]
-      if encoding
-        conn.options(::NB::DB::FMysql::SET_CHARSET_NAME, encoding) rescue nil
-      end
-      conn.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher]) if @config[:sslkey]
-      conn.real_connect(*@connection_options)
-      NB.neverblock(false) do
-        conn.query("SET NAMES '#{encoding}'") if encoding
-        # By default, MySQL 'where id is null' selects the last inserted id.
-        # Turn this off. http://dev.rubyonrails.org/ticket/6778
-        conn.query("SET SQL_AUTO_IS_NULL=0")
+    #initialize the connection pool
+    unless @connection
+      @connection = ::NB::DB::PooledDBConnection.new(@connection_options[0]) do
+        conn = ::NB::DB::FMysql.init
+        encoding = @config[:encoding]
+        if encoding
+          conn.options(::NB::DB::FMysql::SET_CHARSET_NAME, encoding) rescue nil
+        end
+        conn.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher]) if @config[:sslkey]
+        conn.real_connect(*@connection_options[1..(@connection_options.length-1)])
+        NB.neverblock(false) do
+          conn.query("SET NAMES '#{encoding}'") if encoding
+          # By default, MySQL 'where id is null' selects the last inserted id.
+          # Turn this off. http://dev.rubyonrails.org/ticket/6778
+          conn.query("SET SQL_AUTO_IS_NULL=0")
+        end
+        conn
       end
-      conn.register_with_event_loop(:em)
-      conn          
+    else  # we have a connection pool, we need to recover a connection
+      @connection.replace_acquired_connection
     end
-  end  
+  end
 
 end
 

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_options[0]) do
+          conn = PGconn.connect(*@connection_options[1..(@connection_options.length-1)])
+          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.rb

@@ -4,6 +4,7 @@
 
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
+# Thanks to Aman Gupta for writing the Ruby 1.8 Fiber simulator
 unless defined? Fiber
   require 'thread'
   require 'singleton'
@@ -73,12 +74,29 @@ require 'never_block/pool/fiber_pool'
 require 'never_block/pool/fibered_connection_pool'
 
 module NeverBlock
+
+  # Checks if we should be working in a non-blocking mode
+  def self.neverblocking?
+    Fiber.respond_to?(:current) && Fiber.current[:neverblock]
+  end
+
+  def self.event_loop_available?
+    defined?(EM) && EM.reactor_running?
+  end
+
+  # The given block will run its queries either in blocking or non-blocking
+  # mode based on the first parameter
   def self.neverblock(nb = true, &block)
     status = Fiber.current[:neverblock]
     Fiber.current[:neverblock] = nb
     block.call
     Fiber.current[:neverblock] = status
   end
+
+  # Exception to be thrown for all neverblock internal errors
+  class NBError < StandardError
+  end
+
 end
 
 NB = NeverBlock

data/lib/never_block/db/fibered_db_connection.rb

@@ -0,0 +1,64 @@
+module NeverBlock
+  module DB
+    module FiberedDBConnection
+
+      # Attaches the connection socket to an event loop and adds a callback
+      # to the fiber's callbacks that unregisters the connection from event loop
+      # Raises NB::NBError
+      def register_with_event_loop
+        #puts ">>>>>register_with_event_loop"
+        if EM.reactor_running?
+          @fiber = Fiber.current
+          #puts ">>>>>register_with_event_loop fiber #{@fiber.inspect}"
+          # When there's no previous em_connection
+          unless @fiber[:em_connection]
+            @fiber[:em_connection] = EM::attach(socket,EMConnectionHandler,self)
+            @fiber[:callbacks] << self.method(:unregister_from_event_loop)
+          end
+        else
+          raise ::NB::NBError.new("FiberedDBConnection: EventMachine reactor not running")
+        end
+      end  
+
+      # Unattaches the connection socket from the event loop
+      def unregister_from_event_loop
+        #puts ">>>>>unregister_from_event_loop #{self.inspect} #{@fiber.inspect}"
+        if em_c = @fiber[:em_connection]
+          em_c.detach
+          @fiber[:em_connection] = nil
+          true
+        else
+          false
+        end
+      end
+
+      # Removes the unregister_from_event_loop callback from the fiber's
+      # callbacks. It should be used when errors occur in an already registered
+      # connection
+      def remove_unregister_from_event_loop_callbacks
+        @fiber[:callbacks].delete self.method(:unregister_from_event_loop)
+      end
+
+      # Closes the connection using event loop
+      def event_loop_connection_close
+        @fiber[:em_connection].close_connection if @fiber[:em_connection]
+      end
+           
+      # The callback, this is called whenever
+      # there is data available at the socket
+      def resume_command
+        @fiber.resume if @fiber
+      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

@@ -3,115 +3,59 @@ require 'mysqlplus'
 module NeverBlock
 
   module DB
-    # A modified postgres connection driver
-    # builds on the original pg driver.
-    # This driver is able to register the socket
-    # at a certain backend (EM or Rev)
-    # and then whenever the query is executed
-    # within the scope of a friendly fiber
-    # it will be done in async mode and the fiber
-    # will yield
+    # A modified mysql connection driver. It builds on the original pg driver.
+    # This driver is able to register the socket at a certain backend (EM)
+    # and then whenever the query is executed within the scope of a friendly
+    # fiber. 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 self.real_connect(*args)
-        me = super(*args)
-        me.init_descriptor
-        me
+                
+      include FiberedDBConnection
+
+      # Initializes the connection and remembers the connection params
+      def initialize(*args)
+        @connection_params = args
+        super(*@connection_params)
       end
-      #alias :real_connect :initialize
-      #alias :connect :initialize
-      
-      def init_descriptor
-        @fd = socket
-        @io = IO.new(socket)
+
+      # Does a normal real_connect if arguments are passed. If no arguments are
+      # passed it uses the ones it remembers
+      def real_connect(*args)
+        @connection_params = args unless args.empty?
+        super(*@connection_params)
       end
-        
+
+      alias_method :connect, :real_connect
+
       # 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)
-        begin
-          if Fiber.respond_to? :current and Fiber.current[:neverblock]		      
+        if NB.event_loop_available? && NB.neverblocking?
+          raise ::NB::NBError.new("FiberedMysqlConnection: The running fiber is attached to a connection other than the current one") if (c = Fiber.current[:connection]) && c != self
+          begin
             send_query sql
-            @fiber = Fiber.current		      
-            Fiber.yield
-            get_result 
-          else		      
-            super(sql)
-          end
-        rescue Exception => e
-          reconnect if e.msg.include? "not connected"
-          raise e
-        end		
-      end
-
-      # reset the connection
-      # and reattach to the
-      # event loop
-      def reconnect
-        unregister_from_event_loop
-        super
-        init_descriptor
-        register_with_event_loop(@loop)    
-      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
+            Fiber.yield register_with_event_loop
+            get_result
+          rescue Exception => e
+            if error = ['not connected', 'gone away', 'Lost connection'].detect{|msg| e.message.include? msg}
+              event_loop_connection_close
+              unregister_from_event_loop
+              remove_unregister_from_event_loop_callbacks
+              #connect
+            end
+            raise e
           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}")
+          super(sql)
         end
       end
-
-      # The callback, this is called whenever
-      # there is data available at the socket
-      def resume_command
-        @fiber.resume
-      end
       
-    end #FiberedPostgresConnection 
-    
-    # A connection handler for EM
-    # More to follow.
-    module EMConnectionHandler
-      def initialize connection
-        @connection = connection
-      end
-      def notify_readable
-        @connection.resume_command
-      end
-    end
+      alias_method :exec, :query
+
+    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,32 +13,21 @@ 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)
-        init_descriptor
-        #setnonblocking(true)
-      end
-      
-      def init_descriptor
-        @fd = socket
-        @io = IO.new(socket)
-      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)
-        begin
-          if Fiber.respond_to? :current and Fiber.current[:neverblock]		      
+        # TODO Still not "killing the query process"-proof
+        # In some cases, the query is simply sent but the fiber never yields
+        if NB.event_loop_available? && NB.neverblocking?
+          begin
             send_query sql
-            @fiber = Fiber.current		      
-            Fiber.yield 
+            @fiber = Fiber.current
+            Fiber.yield register_with_event_loop
             while is_busy
               consume_input
               Fiber.yield if is_busy
@@ -47,77 +37,25 @@ module NeverBlock
               res = self.get_result
               data << res unless res.nil?
             end
-            data.last          
-          else		      
-            super(sql)
-          end
-        rescue Exception => e
-          reset if e.msg.include? "not connected"
-          raise e
-        end		
-      end
-
-      # reset the connection
-      # and reattach to the
-      # event loop
-      def reset
-        unregister_from_event_loop
-        super
-        init_descriptor
-        register_with_event_loop(@loop)    
-      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
+            data.last
+          rescue Exception => e
+            if error = ['not connected', 'gone away', 'Lost connection','no connection'].detect{|msg| e.message.include? msg}
+              #event_loop_connection_close
+              unregister_from_event_loop
+              reset
+            end
+            raise e
+          ensure
+            unregister_from_event_loop
           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"
+          super(sql)
         end
-        @loop = loop
       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
-
-      # The callback, this is called whenever
-      # there is data available at the socket
-      def resume_command
-        #let the fiber continue its work		      
-        @fiber.resume
-      end
-      
+      alias_method :query, :exec
+            
     end #FiberedPostgresConnection 
-    
-    # A connection handler for EM
-    # More to follow.
-    module EMConnectionHandler
-      def initialize connection
-        @connection = connection
-      end
-      def notify_readable
-        @connection.resume_command
-      end
-    end
 
     end #DB
 

data/lib/never_block/db/pooled_db_connection.rb

@@ -0,0 +1,43 @@
+module NeverBlock
+  module DB
+    # 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)
+        @pool.hold do |conn|
+          conn.query(query)
+        end
+      end
+
+      alias :exec :query
+
+      # Replaces the current connection with a brand new one
+      def replace_acquired_connection
+        @pool.replace_acquired_connection
+      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

data/lib/never_block/extensions/fiber_extensions.rb

@@ -25,6 +25,7 @@ class Fiber
   
   def local_fiber_variables
     @local_fiber_variables ||= {}
-  end    
+  end
+
 end
 

data/lib/never_block/pool/fiber_pool.rb

@@ -1,12 +1,3 @@
-# we need Fiber.current
-# so we must require
-# fiber
-# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
-# Copyright:: Copyright (c) 2008 eSpace, Inc.
-# License::   Distributes under the same terms as Ruby
-
-#require 'fiber'
-
 module NeverBlock
   module Pool
 
@@ -31,46 +22,52 @@ module NeverBlock
     #   end
     # end
     #
-	  class FiberPool
+    class FiberPool
+
+      # 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,@busy_fibers,@queue = [],{},[]
+        count.times do |i|
+          fiber = Fiber.new do |block|
+            loop do
+              block.call
+              # callbacks are called in a reverse order, much like c++ destructor
+              Fiber.current[:callbacks].pop.call while Fiber.current[:callbacks].length > 0
+              unless @queue.empty?
+                block = @queue.shift
+              else
+                @busy_fibers.delete(Fiber.current.object_id)
+                @fibers << Fiber.current
+                block = Fiber.yield
+              end
+            end
+          end
+          fiber[:callbacks] = []
+          fiber[:neverblock] = true
+          @fibers << fiber
+        end
+      end
 
-	    # gives access to the currently free fibers
-		  attr_reader :fibers
+      # 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[:callbacks] = []
+          @busy_fibers[fiber.object_id] = fiber
+          fiber[:neverblock] = evented
+          fiber.resume(block)
+        else
+          @queue << block
+        end
+        self # we are keen on hiding our queue
+      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
+    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

@@ -1,14 +1,5 @@
-# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
-# Copyright:: Copyright (c) 2008 eSpace, Inc.
-# License::   Distributes under the same terms as Ruby
-
 module NeverBlock
   module Pool
-    
-    # Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
-    # Copyright:: Copyright (c) 2008 eSpace, Inc.
-    # License::   Distributes under the same terms as Ruby
-    #
 		# This class represents a pool of connections, 
 		# you hold or release conncetions from the pool
 		# hold requests that cannot be fullfiled will be queued
@@ -25,19 +16,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,38 +45,23 @@ 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
-      # before releasing the connection
-      # if inside a transaction, don't release the fiber
-			def hold(transactional = false)
-			  fiber = Fiber.current
-			  if conn = @busy_connections[fiber]
-			    return yield(conn)
-			  end
-			  conn = acquire(fiber)
-			  begin
-			    yield conn
-			  ensure
-			    release(fiber, conn) unless transactional
-					process_queue 
-			  end
-			end
+      def replace_acquired_connection
+        fiber = Fiber.current
+        conn = @connection_proc.call
+        @busy_connections[fiber] = conn
+        fiber[:connection] = conn
+      end
 
-      # Give the fiber back to the pool
-      # you have to call this explicitly if
-      # you held a connection for a transaction
-			def release(fiber, conn)
-				@busy_connections.delete(fiber)
-				@connections << conn
+      # If a connection is available, pass it to the block, otherwise pass
+      # the fiber to the queue till a connection is available
+			def hold()
+			  fiber = Fiber.current
+        conn = acquire(fiber)
+        yield conn
 			end
 
       def all_connections
@@ -89,14 +74,36 @@ module NeverBlock
       # Can we create one?
       # Wait in the queue then
 			def acquire(fiber)
-				if !@connections.empty?
-					@busy_connections[fiber] = @connections.shift
-				elsif (@connections.length + @busy_connections.length) < @size
-					conn = @connection_proc.call
-					@busy_connections[fiber] = conn
-				else
+        # A special case for rails when doing ActiveRecord stuff when not yet
+        # running in the context of a request (fiber) like in the case of AR
+        # queries in environment.rb (Root Fiber)
+        return @connections.first unless fiber[:callbacks]
+
+        return fiber[:connection] if fiber[:connection]
+        conn =  if !@connections.empty?
+          @connections.shift
+        elsif (@connections.length + @busy_connections.length) < @size
+          @connection_proc.call
+        else
 					Fiber.yield @queue << fiber
-				end
+        end
+
+        # They're called in reverse order i.e. release then process_queue
+        fiber[:callbacks] << self.method(:process_queue)
+        fiber[:callbacks] << self.method(:release)
+
+        @busy_connections[fiber] = conn
+        fiber[:connection] = conn
+			end
+
+      # Give the fiber's connection back to the pool
+			def release()
+        fiber = Fiber.current
+        if fiber[:connection]
+				  @busy_connections.delete(fiber)
+				  @connections << fiber[:connection]
+          fiber[:connection] = nil
+        end
 			end
 
       # Check if there are waiting fibers and
@@ -106,8 +113,8 @@ module NeverBlock
 					fiber = @queue.shift
 					# What is really happening here?
 					# we are resuming a fiber from within
-					# another, should we call transfer insted?
-					fiber.resume @busy_connections[fiber] = @connections.shift
+					# another, should we call transfer instead?
+					fiber.resume @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/lib/neverblock-pg.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/pooled_db_connection'
 require 'never_block/db/fibered_postgres_connection'
-require 'never_block/db/pooled_fibered_postgres_connection'

data/neverblock.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "neverblock"
-  s.version  = "0.1.4"
-  s.date     = "2008-09-04"
+  s.version  = "0.1.5"
+  s.date     = "2008-11-06"
   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: espace-neverblock
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 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-11-06 00:00:00 -08: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_mysql_connection.rb

@@ -1,77 +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 PooledFiberedMysqlConnection
-
-      # Requires a hash or an array 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)
-        @pool.hold do |conn|
-          conn.query(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.query("begin")
-        end
-      end
-      
-      # see =begin_db_transaction
-      def rollback_db_transaction
-        @pool.hold do |conn|
-          conn.query("rollback")
-          @pool.release(Fiber.current,conn)
-        end
-      end
-      
-      # see =begin_db_transaction
-      def commit_db_transaction
-        @pool.hold do |conn|
-          conn.query("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
-
-NeverBlock::DB::PFMysql = NeverBlock::DB::PooledFiberedMysqlConnection

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
-