espace-neverblock 0.1.2

data/README

@@ -0,0 +1,21 @@
+== NeverBlock
+Never, ever!
+
+NeverBlock is a collection of classes and modules that help you write evented non-blocking applications in a seemingly blocking mannner.
+
+NeverBlock currently provides the following Libraries:
+
+=== FiberExtensions
+A set of extenstions to the standard Fiber implementation
+
+=== NeverBlock::Pool::FiberPool 
+A pool of fibers that can be used to provide an upper limit to the numbers of active fibers in an application
+
+=== NeverBlock::Pool::FiberedConnectionPool
+A generic fibered connection pool for all sorts of connections with support for transactions. This was mostly copied from Sequel::ConnectionPool
+
+NeverBlock should be the basis for providing completely async Ruby application development that does not require the usual twisted style of evented programming. For example, you will be able to develop in Rails in the usual style and deploy to a NeverBlock server which will do all the IO in an evented manner without you even noticing this. 
+
+=== License
+Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.
+

data/lib/active_record/connection_adapters/neverblock_mysql_adapter.rb

@@ -0,0 +1,80 @@
+require 'activesupport'
+require 'never_block/frameworks/activerecord'
+require 'active_record/connection_adapters/mysql_adapter'
+require 'neverblock-mysql'
+
+class ActiveRecord::ConnectionAdapters::NeverBlockMysqlAdapter < ActiveRecord::ConnectionAdapters::MysqlAdapter
+
+  # Returns 'NeverBlockMySQL' as adapter name for identification purposes
+  def adapter_name
+    'NeverBlockMySQL'
+  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")
+      end
+      conn.register_with_event_loop(:em)
+      conn          
+    end
+  end  
+
+end
+
+class ActiveRecord::Base
+  # Establishes a connection to the database that's used by all Active Record objects
+  def self.neverblock_mysql_connection(config) # :nodoc:
+    config = config.symbolize_keys
+    host     = config[:host]
+    port     = config[:port]
+    socket   = config[:socket]
+    username = config[:username] ? config[:username].to_s : 'root'
+    password = config[:password].to_s
+    size     = config[:connections] || 4
+
+    if config.has_key?(:database)
+      database = config[:database]
+    else
+      raise ArgumentError, "No database specified. Missing argument: database."
+    end
+    MysqlCompat.define_all_hashes_method!
+    ::ActiveRecord::ConnectionAdapters::NeverBlockMysqlAdapter.new(nil, logger, [size.to_i, host, username, password, database, port, socket, nil], config)
+  end  
+end

data/lib/active_record/connection_adapters/neverblock_postgresql_adapter.rb

@@ -0,0 +1,102 @@
+require 'active_record/connection_adapters/postgresql_adapter'
+require 'neverblock-pg'
+require 'never_block/frameworks/activerecord'
+
+
+class ActiveRecord::ConnectionAdapters::NeverBlockPostgreSQLAdapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      # Returns 'FiberedPostgreSQL' as adapter name for identification purposes.
+      def adapter_name
+        'NeverBlockPostgreSQL'
+      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
+      # Executes an INSERT query and returns the new record's ID, this wont
+      # work on earlier versions of PostgreSQL but they don't suppor the async
+      # interface anyway
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        @connection.exec(sql << " returning id ") 
+      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
+              end
+            end
+          end_eval
+
+          configure_connection
+          @connection.commit_db_transaction
+
+        end
+
+      end
+
+      # Close then reopen the connection.
+      def reconnect!
+        disconnect!
+        connect
+      end
+
+end
+
+class ActiveRecord::Base
+  # Establishes a connection to the database that's used by all Active Record objects
+  def self.neverblock_postgresql_connection(config) # :nodoc:
+    config = config.symbolize_keys
+    host     = config[:host]
+    port     = config[:port] || 5432
+    username = config[:username].to_s
+    password = config[:password].to_s
+    size     = config[:connections] || 4
+
+    if config.has_key?(:database)
+      database = config[:database]
+    else
+      raise ArgumentError, "No database specified. Missing argument: database."
+    end
+
+    # The postgres drivers don't allow the creation of an unconnected PGconn object,
+    # so just pass a nil connection object for the time being.
+    ::ActiveRecord::ConnectionAdapters::NeverBlockPostgreSQLAdapter.new(nil, logger, [size, host, port, nil, nil, database, username, password], config)
+  end  
+end

data/lib/never_block/db/fibered_mysql_connection.rb

@@ -0,0 +1,97 @@
+require 'mysql'
+
+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
+	  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
+        
+      # 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
+          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
+      end
+
+      # The callback, this is called whenever
+      # there is data available at the socket
+      def process_command
+        @fiber.resume get_result
+      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
+
+end #NeverBlock
+
+NeverBlock::DB::FMysql = NeverBlock::DB::FiberedMysqlConnection

data/lib/never_block/db/fibered_postgres_connection.rb

@@ -0,0 +1,109 @@
+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
+    # 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
+	  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
+        
+      # 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
+          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
+      # 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 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
+      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
+
+end #NeverBlock
+
+NeverBlock::DB::FPGconn = NeverBlock::DB::FiberedPostgresConnection

data/lib/never_block/db/pooled_fibered_mysql_connection.rb

@@ -0,0 +1,78 @@
+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 exec method
+      # quries the pool to get a connection first
+      def exec(query)
+        @pool.hold do |conn|
+          conn.query(query)
+        end
+      end
+      
+      alias :query :exec
+      # 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
+
+NeverBlock::DB::PFMysql = NeverBlock::DB::PooledFiberedMysqlConnection

data/lib/never_block/db/pooled_fibered_postgres_connection.rb

@@ -0,0 +1,81 @@
+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
+

data/lib/never_block/extensions/fiber_extensions.rb

@@ -0,0 +1,30 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2008 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+# If this file is meant to be used out of neverblock, then uncomment
+# the following line
+#require 'fiber'
+
+class Fiber
+  
+  #Attribute Reference--Returns the value of a fiber-local variable, using
+  #either a symbol or a string name. If the specified variable does not exist,
+  #returns nil.
+  def [](key)
+    local_fiber_variables[key]
+  end
+  
+  #Attribute Assignment--Sets or creates the value of a fiber-local variable,
+  #using either a symbol or a string. See also Fiber#[].
+  def []=(key,value)
+    local_fiber_variables[key] = value
+  end
+  
+  private
+  
+  def local_fiber_variables
+    @local_fiber_variables ||= {}
+  end    
+end
+

data/lib/never_block/frameworks/activerecord.rb

@@ -0,0 +1,37 @@
+require 'activerecord'
+
+# Patch ActiveRecord to store transaction depth information
+# in fibers instead of threads. AR does not support nested
+# transactions which makes the job easy.
+# We also need to override the scoped methods to store
+# the scope in the fiber context
+class ActiveRecord::Base
+
+  def single_threaded_scoped_methods #:nodoc:
+    scoped_methods = (Fiber.current[:scoped_methods] ||= {})
+    scoped_methods[self] ||= []
+  end
+
+  def self.transaction(&block)
+    increment_open_transactions
+    begin
+      connection.transaction(Fiber.current['start_db_transaction'], &block)
+    ensure
+      decrement_open_transactions
+    end
+  end
+
+  private
+
+  def self.increment_open_transactions #:nodoc:
+    open = Fiber.current['open_transactions'] ||= 0
+    Fiber.current['start_db_transaction'] = open.zero?
+    Fiber.current['open_transactions'] = open + 1
+  end
+
+  def self.decrement_open_transactions #:nodoc:
+    Fiber.current['open_transactions'] -= 1
+  end
+  
+end
+

data/lib/never_block/frameworks/rails.rb

@@ -0,0 +1,37 @@
+require 'neverblock' unless defined?(NeverBlock)
+#require 'actionpack'
+#require 'action_controller'
+
+# Rails tries to protect dispatched actions
+# by wrapping them in a synchronized code
+# block, since fibers hate synchronized
+# blocks we will trick the guard and
+# 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)
+    # now you don't!
+    block.call
+  end
+end
+=end
+
+
+require 'thread'
+
+# now you synchronize
+class Mutex
+  def synchronize(&block)
+    # now you don't!
+    block.call
+  end
+end

data/lib/never_block/pool/fiber_pool.rb

@@ -0,0 +1,76 @@
+# 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
+
+    # Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+    # Copyright:: Copyright (c) 2008 eSpace, Inc.
+    # License::   Distributes under the same terms as Ruby
+    #
+    #	A pool of initialized fibers
+    #	It does not grow in size or create transient fibers
+    #	It will queue code blocks when needed (if all its fibers are busy)
+    #
+    # This class is particulary useful when you use the fibers 
+    # to connect to evented back ends. It also does not generate
+    # transient objects and thus saves memory.
+    #
+    # Example:
+    # fiber_pool = NeverBlock::Pool::FiberPool.new(150)
+    # 
+    # loop do
+    #   fiber_pool.spawn do
+    #     #fiber body goes here 
+    #   end
+    # end
+    #
+	  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,@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
+	end
+end

data/lib/never_block/pool/fibered_connection_pool.rb

@@ -0,0 +1,118 @@
+# 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
+		# the fiber will be paused and resumed later when
+		# a connection is avaialble
+		#
+		# Large portions of this class were copied and pasted
+		# form Sequel's threaded connection pool
+    #
+    # Example:
+    #
+    # pool = NeverBlock::Pool::FiberedConnectionPool.new(:size=>16)do
+    #   # connection creation code goes here   
+    # 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 
+    #   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
+    # 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)     
+			def initialize(options = {}, &block)
+				@connections, @busy_connections, @queue = [], {},[]
+				@connection_proc = block
+				@size = options[:size] || 8
+				if options[:eager]
+				  @size.times do
+				    @connections << @connection_proc.call
+				  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
+
+      # 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
+			end
+
+      def all_connections
+        (@connections + @busy_connections.values).each {|conn| yield(conn)}
+      end
+
+      private
+
+      # Can we find a connection?
+      # 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
+					Fiber.yield @queue << fiber
+				end
+			end
+
+      # Check if there are waiting fibers and
+      # try to process them
+			def process_queue
+				while !@connections.empty? and !@queue.empty?
+					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
+				end
+			end
+			
+		end #FiberedConnectionPool
+		
+	end #Pool
+
+end #NeverBlock

data/lib/never_block/servers/thin.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'neverblock' unless defined?(NeverBlock)
+require 'thin'
+
+module Thin
+  
+  # Patch the thin server to use 
+  # NeverBlock::Pool::FiberPool
+  # to be able to wrap requests
+  # in fibers
+  class Server
+
+    DEFAULT_FIBER_POOL_SIZE = 20
+
+    def fiber_pool
+      @fiber_pool ||= NB::Pool::FiberPool.new(DEFAULT_FIBER_POOL_SIZE)
+    end  
+
+  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
+  class Connection < EventMachine::Connection
+
+    def process
+        @request.threaded = false
+        @backend.server.fiber_pool.spawn{post_process(pre_process)}
+    end
+    
+  end # Connection
+
+
+end # Thin

data/lib/never_block.rb

@@ -0,0 +1,84 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2008 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+unless defined? Fiber
+  require 'thread'
+  require 'singleton'
+  class FiberError < StandardError; end
+  class Fiber
+    def initialize
+      raise ArgumentError, 'new Fiber requires a block' unless block_given?
+ 
+      @yield = Queue.new
+      @resume = Queue.new
+
+      @thread = Thread.new{ @yield.push [ *yield(*@resume.pop) ] }
+      @thread.abort_on_exception = true
+      @thread[:fiber] = self
+    end
+    attr_reader :thread
+ 
+    def resume *args
+      raise FiberError, 'dead fiber called' unless @thread.alive?
+      @resume.push(args)
+      result = @yield.pop
+      result.size > 1 ? result : result.first
+    end
+    
+    def yield *args
+      @yield.push(args)
+      result = @resume.pop
+      result.size > 1 ? result : result.first
+    end
+    
+    def self.yield *args
+      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
+      fiber.yield(*args)
+    end
+ 
+    def self.current
+      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
+    end
+ 
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+
+  class RootFiber < Fiber
+    include Singleton
+    def initialize
+    end
+
+    def resume *args
+      raise FiberError, "can't resume root fiber"
+    end
+
+    def yield *args
+      raise FiberError, "can't yield from root fiber"
+    end
+  end
+
+  #attach the root fiber to the main thread
+  Thread.main[:fiber] = RootFiber.instance
+else
+  require 'fiber'
+end
+
+require 'never_block/extensions/fiber_extensions'
+require 'never_block/pool/fiber_pool'
+require 'never_block/pool/fibered_connection_pool'
+
+module NeverBlock
+  def self.neverblock(nb = true, &block)
+    status = Fiber.current[:neverblock]
+    Fiber.current[:neverblock] = nb
+    block.call
+    Fiber.current[:neverblock] = status
+  end
+end
+
+NB = NeverBlock

data/lib/neverblock-mysql.rb

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

data/lib/neverblock-pg.rb

@@ -0,0 +1,4 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'never_block/db/fibered_postgres_connection'
+require 'never_block/db/pooled_fibered_postgres_connection'

data/lib/neverblock.rb

@@ -0,0 +1,8 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2008 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'never_block'
+

data/neverblock.gemspec

@@ -0,0 +1,35 @@
+Gem::Specification.new do |s|
+  s.name     = "neverblock"
+  s.version  = "0.1.2"
+  s.date     = "2008-09-04"
+  s.summary  = "Utilities for non-blocking stack components"
+  s.email    = "oldmoe@gmail.com"
+  s.homepage = "http://github.com/oldmoe/neverblock"
+  s.description = "NeverBlock is a collection of classes and modules that help you write evented non-blocking applications in a seemingly blocking mannner."
+  s.has_rdoc = true
+  s.authors  = ["Muhammad A. Ali", "Ahmed Sobhi", "Osama Brekaa"]
+  s.files    = [ 
+		"neverblock.gemspec", 
+		"README", 
+		"lib/neverblock.rb", 
+		"lib/never_block.rb", 
+		"lib/neverblock-pg.rb", 
+		"lib/neverblock-mysql.rb", 
+		"lib/never_block/extensions/fiber_extensions.rb", 
+		"lib/never_block/pool/fiber_pool.rb", 
+		"lib/never_block/pool/fibered_connection_pool.rb",
+    "lib/never_block/frameworks/rails.rb",
+    "lib/never_block/frameworks/activerecord.rb",
+    "lib/never_block/servers/thin.rb",
+    "lib/never_block/db/fibered_postgres_connection.rb",
+    "lib/never_block/db/pooled_fibered_postgres_connection.rb",
+    "lib/never_block/db/fibered_mysql_connection.rb",
+    "lib/never_block/db/pooled_fibered_mysql_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"]
+end
+
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: espace-neverblock
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Muhammad A. Ali
+- Ahmed Sobhi
+- Osama Brekaa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+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: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- neverblock.gemspec
+- README
+- lib/neverblock.rb
+- lib/never_block.rb
+- lib/neverblock-pg.rb
+- lib/neverblock-mysql.rb
+- lib/never_block/extensions/fiber_extensions.rb
+- lib/never_block/pool/fiber_pool.rb
+- lib/never_block/pool/fibered_connection_pool.rb
+- lib/never_block/frameworks/rails.rb
+- lib/never_block/frameworks/activerecord.rb
+- lib/never_block/servers/thin.rb
+- lib/never_block/db/fibered_postgres_connection.rb
+- lib/never_block/db/pooled_fibered_postgres_connection.rb
+- lib/never_block/db/fibered_mysql_connection.rb
+- lib/never_block/db/pooled_fibered_mysql_connection.rb
+- lib/active_record/connection_adapters/neverblock_postgresql_adapter.rb
+- lib/active_record/connection_adapters/neverblock_mysql_adapter.rb
+has_rdoc: true
+homepage: http://github.com/oldmoe/neverblock
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Utilities for non-blocking stack components
+test_files: []
+