neverblock 0.1.6.2

data/lib/never_block/db/fibered_postgres_connection.rb

@@ -0,0 +1,64 @@
+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	      
+              
+      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)
+        # 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 register_with_event_loop
+            while is_busy
+              consume_input
+              Fiber.yield if is_busy
+            end
+            res, data = 0, []
+            while res != nil
+              res = self.get_result
+              data << res unless res.nil?
+            end
+            data.last
+          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
+        else
+          super(sql)
+        end
+      end
+
+      alias_method :query, :exec
+            
+    end #FiberedPostgresConnection 
+
+    end #DB
+
+end #NeverBlock
+
+NeverBlock::DB::FPGconn = NeverBlock::DB::FiberedPostgresConnection

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

@@ -0,0 +1,31 @@
+# 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 &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,65 @@
+require 'neverblock' unless defined?(NeverBlock)
+
+# 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
+
+require 'thread'
+# now you synchronize
+class Mutex
+  def synchronize(&block)
+    # now you don't!
+    block.call
+  end
+end
+
+require 'action_controller'
+class ActionController::Base
+
+  # Mark some actions to execute in a blocking manner overriding the default
+  # settings.
+  # Example:
+  #   class UsersController < ApplicationController
+  #     .
+  #     allowblock :index
+  #     .
+  #   end
+  def self.allowblock(*actions)
+    actions.each do |action|
+      class_eval <<-"end_eval"
+        def allowblock_#{action}
+          status = Fiber.current[:neverblock]
+          Fiber.current[:neverblock] = false
+          yield
+          Fiber.current[:neverblock] = status
+        end
+        around_filter :allowblock_#{action}, :only => [:#{action}]
+      end_eval
+    end
+  end
+
+  # Mark some actions to execute in a non-blocking manner overriding the default
+  # settings.
+  # Example:
+  #   class UsersController < ApplicationController
+  #     .
+  #     allowblock :index
+  #     .
+  #   end
+  def self.neverblock(*actions)
+    actions.each do |action|
+      class_eval <<-"end_eval"
+        def neverblock_#{action}
+          status = Fiber.current[:neverblock]
+          Fiber.current[:neverblock] = true
+          yield
+          Fiber.current[:neverblock] = status
+        end
+        around_filter :allowblock_#{action}, :only => [:#{action}]
+      end_eval
+    end
+  end
+end

data/lib/never_block/pool/fiber_pool.rb

@@ -0,0 +1,74 @@
+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,@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[:em_keys] = []
+          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[: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
+
+    end # FiberPool
+  end # Pool
+end # NeverBlock
+

data/lib/never_block/pool/fibered_connection_pool.rb

@@ -0,0 +1,130 @@
+module NeverBlock
+  module Pool
+		# 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
+    #     # 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
+    # It is the responsibility of client code to release the connection
+		class FiberedConnectionPool
+
+      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
+				@size = options[:size] || 8
+				if options[:eager]
+				  @size.times do
+				    @connections << @connection_proc.call
+				  end
+				end
+			end
+
+      def replace_acquired_connection
+        fiber = Fiber.current
+        conn = @connection_proc.call
+        @busy_connections[fiber] = conn
+        fiber[connection_pool_key] = conn
+      end
+
+      # 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
+        (@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)
+        # 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]
+
+        fiber[:current_pool_key] = connection_pool_key
+        return fiber[connection_pool_key] if fiber[connection_pool_key]
+        conn =  if !@connections.empty?
+          @connections.shift
+        elsif (@connections.length + @busy_connections.length) < @size
+          @connection_proc.call
+        else
+					Fiber.yield @queue << fiber
+        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_pool_key] = conn
+			end
+
+      # Give the fiber's connection back to the pool
+			def release()
+        fiber = Fiber.current
+        if fiber[connection_pool_key]
+				  @busy_connections.delete(fiber)
+				  @connections << fiber[connection_pool_key]
+          fiber[connection_pool_key] = nil
+        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 instead?
+					fiber.resume @connections.shift
+				end
+			end
+			
+			def connection_pool_key
+			  @connection_pool_key ||= "connection_pool_#{object_id}".intern
+		  end
+			
+		end #FiberedConnectionPool
+		
+	end #Pool
+
+end #NeverBlock