oldmoe-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::PooledDBConnection.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,8 +28,8 @@ class ActiveRecord::ConnectionAdapters::NeverBlockPostgreSQLAdapter < ActiveReco
       end
 
       def connect
-        @connection = ::NB::DB::PooledFiberedPostgresConnection.new(@connection_parameters.shift) do
-          conn = PGconn.connect(*@connection_parameters)
+        @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)

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

@@ -1,46 +1,53 @@
 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"
+
+      # 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
-        elsif loop.class.name == "REV::Loop"
-          loop.attach(RevConnectionHandler.new(@fd))
         else
-          raise "could not register with the event loop"
+          raise ::NB::NBError.new("FiberedDBConnection: EventMachine reactor not running")
         end
-        @loop = loop
       end  
 
       # Unattaches the connection socket from the event loop
       def unregister_from_event_loop
-        if @loop == :em
-          @em_connection.detach
+        #puts ">>>>>unregister_from_event_loop #{self.inspect} #{@fiber.inspect}"
+        if em_c = @fiber[:em_connection]
+          em_c.detach
+          @fiber[:em_connection] = nil
+          true
         else
-          raise NotImplementedError.new("unregister_from_event_loop not implemented for #{@loop}")
+          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
-        #protection against being called several times
-        if @fiber
-          f = @fiber
-          @fiber = nil
-          f.resume
-        else
-          unregister_from_event_loop
-        end
+        @fiber.resume if @fiber
       end
       
     end

data/lib/never_block/db/fibered_mysql_connection.rb

@@ -3,55 +3,57 @@ require 'mysqlplus'
 module NeverBlock
 
   module DB
-    # 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)
-    # 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	      
                 
       include FiberedDBConnection
-        
+
+      # Initializes the connection and remembers the connection params
+      def initialize(*args)
+        @connection_params = args
+        super(*@connection_params)
+      end
+
+      # 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)
+            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
-        rescue Exception => e
-          if error = ['not connected', 'gone away', 'Lost connection'].detect{|msg| e.message.include? msg}
-            stop
-            connect
-          end
-          raise e
-        end		
-      end
-
-      alias :exec :query
-      
-      # stop the connection and deattach from the event loop
-      def stop
-        unregister_from_event_loop
+        else
+          super(sql)
+        end
       end
       
-      # reconnect and attach to the event loop
-      def connect
-        super
-        register_with_event_loop(@loop)    
-      end
-            
-    end #FiberedMySQLConnection 
+      alias_method :exec, :query
+
+    end #FiberedMySQLConnection
 
   end #DB
 

data/lib/never_block/db/fibered_postgres_connection.rb

@@ -21,11 +21,13 @@ module NeverBlock
       # 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
@@ -35,26 +37,23 @@ module NeverBlock
               res = self.get_result
               data << res unless res.nil?
             end
-            data.last          
-          else		      
-            super(sql)
+            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
-        rescue Exception => e
-          reset if e.message.include? "not connected"
-          raise e
-        end		
+        else
+          super(sql)
+        end
       end
 
-      alias :query :exec
-
-      # reset the connection
-      # and reattach to the
-      # event loop
-      def reset
-        unregister_from_event_loop
-        super
-        register_with_event_loop(@loop)    
-      end
+      alias_method :query, :exec
             
     end #FiberedPostgresConnection 
 

data/lib/never_block/db/pooled_db_connection.rb

@@ -19,40 +19,12 @@ module NeverBlock
       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
-      # 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.close
-        end
+      # 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|

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
 
@@ -40,18 +31,23 @@ module NeverBlock
       # 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 = [],[]
+        @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
-                block = Fiber.yield @fibers << Fiber.current
+                @busy_fibers.delete(Fiber.current.object_id)
+                @fibers << Fiber.current
+                block = Fiber.yield
               end
             end
           end
+          fiber[:callbacks] = []
           fiber[:neverblock] = true
           @fibers << fiber
         end
@@ -61,6 +57,8 @@ module NeverBlock
       # 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

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
@@ -58,31 +49,19 @@ module NeverBlock
 				end
 			end
 
+      def replace_acquired_connection
+        fiber = Fiber.current
+        conn = @connection_proc.call
+        @busy_connections[fiber] = conn
+        fiber[:connection] = conn
+      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)
+			def hold()
 			  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
-
-      # 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
+        conn = acquire(fiber)
+        yield conn
 			end
 
       def all_connections
@@ -95,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
@@ -113,7 +114,7 @@ module NeverBlock
 					# What is really happening here?
 					# we are resuming a fiber from within
 					# another, should we call transfer instead?
-					fiber.resume @busy_connections[fiber] = @connections.shift
+					fiber.resume @connections.shift
 				end
 			end
 			

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-20"
+  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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: oldmoe-neverblock
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Muhammad A. Ali
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-20 00:00:00 -07:00
+date: 2008-11-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency