oldmoe-neverblock 0.1.6 → 1.0

data/lib/never_block/db/fibered_postgres_connection.rb

@@ -1,64 +0,0 @@
-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/frameworks/activerecord.rb

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

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

@@ -1,74 +0,0 @@
-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/servers/mongrel.rb

@@ -1,236 +0,0 @@
-# This module rewrites pieces of the very good Mongrel web server in
-# order to change it from a threaded application to an event based
-# application running inside an EventMachine event loop.  It should
-# be compatible with the existing Mongrel handlers for Rails,
-# Camping, Nitro, etc....
-
-# NeverBlock support added
-
-begin
-	load_attempted ||= false
-	require 'eventmachine'
-rescue LoadError
-	unless load_attempted
-		load_attempted = true
-		require 'rubygems'
-		retry
-	end
-end
-
-require 'rubygems'
-require 'neverblock'
-require 'mongrel'
-
-module Mongrel
-	class MongrelProtocol < EventMachine::Connection
-		def post_init
-			@parser = HttpParser.new
-			@params = HttpParams.new
-			@nparsed = 0
-			@request = nil
-			@request_len = nil
-			@linebuffer = ''
-		end
-
-		def receive_data data
-			@linebuffer << data
-			@nparsed = @parser.execute(@params, @linebuffer, @nparsed) unless @parser.finished?
-			if @parser.finished?
-				if @request_len.nil?
-					@request_len = @params[::Mongrel::Const::CONTENT_LENGTH].to_i
-					script_name, path_info, handlers = ::Mongrel::HttpServer::Instance.classifier.resolve(@params[::Mongrel::Const::REQUEST_PATH])
-					if handlers
-						@params[::Mongrel::Const::PATH_INFO] = path_info
-						@params[::Mongrel::Const::SCRIPT_NAME] = script_name
-						@params[::Mongrel::Const::REMOTE_ADDR] = @params[::Mongrel::Const::HTTP_X_FORWARDED_FOR] || ::Socket.unpack_sockaddr_in(get_peername)[1]
-						@notifiers = handlers.select { |h| h.request_notify }
-					end
-					if @request_len > ::Mongrel::Const::MAX_BODY
-						new_buffer = Tempfile.new(::Mongrel::Const::MONGREL_TMP_BASE)
-						new_buffer.binmode
-						new_buffer << @linebuffer[@nparsed..-1]
-						@linebuffer = new_buffer
-					else
-						@linebuffer = StringIO.new(@linebuffer[@nparsed..-1])
-						@linebuffer.pos = @linebuffer.length
-					end
-				end
-				if @linebuffer.length >= @request_len
-					@linebuffer.rewind
-					::Mongrel::HttpServer::Instance.process_http_request(@params,@linebuffer,self)
-					@linebuffer.delete if Tempfile === @linebuffer
-				end
-			elsif @linebuffer.length > ::Mongrel::Const::MAX_HEADER
-				close_connection
-				raise ::Mongrel::HttpParserError.new("HEADER is longer than allowed, aborting client early.")
-			end
-		rescue ::Mongrel::HttpParserError
-			if $mongrel_debug_client
-				STDERR.puts "#{Time.now}: BAD CLIENT (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #$!"
-				STDERR.puts "#{Time.now}: REQUEST DATA: #{data.inspect}\n---\nPARAMS: #{params.inspect}\n---\n"
-			end
-			close_connection
-		rescue Exception => e
-			close_connection
-			raise e
-		end
-
-		def write data
-			send_data data
-		end
-
-		def closed?
-			false
-		end
-
-	end
-
-	class HttpServer
-    DEFAULT_FIBER_POOL_SIZE = 20
-		def initialize(host, port, num_processors=950, x=0, y=nil) # Deal with Mongrel 1.0.1 or earlier, as well as later.
-			@socket = nil
-			@classifier = URIClassifier.new
-			@host = host
-			@port = port
-			@workers = ThreadGroup.new
-			if y
-				@throttle = x
-				@timeout = y || 60
-			else
-				@timeout = x
-			end
-			@num_processors = num_processors #num_processors is pointless for evented....
-			@death_time = 60
-			self.class.const_set(:Instance,self)
-		end
-
-    def fiber_pool
-      @fiber_pool ||= NB::Pool::FiberPool.new(DEFAULT_FIBER_POOL_SIZE)
-    end
-
-		def run
-			trap('INT') { raise StopServer }
-			trap('TERM') { raise StopServer }
-			@acceptor = Thread.new do
-				EventMachine.epoll
-				EventMachine.set_descriptor_table_size(4096)
-				EventMachine.run do
-					begin
-						EventMachine.start_server(@host,@port,MongrelProtocol)
-					rescue StopServer
-						EventMachine.stop_event_loop
-					end
-				end
-			end
-		end
-
-		def process_http_request(params,linebuffer,client)
-			if not params[Const::REQUEST_PATH]
-				uri = URI.parse(params[Const::REQUEST_URI])
-				params[Const::REQUEST_PATH] = uri.request_uri
-			end
-
-      raise "No REQUEST PATH" if not params[Const::REQUEST_PATH]
-
-			script_name, path_info, handlers = @classifier.resolve(params[Const::REQUEST_PATH])
-
-			if handlers
-				notifiers = handlers.select { |h| h.request_notify }
-				request = HttpRequest.new(params, linebuffer, notifiers)
-
-				# request is good so far, continue processing the response
-				response = HttpResponse.new(client)
-
-				# Process each handler in registered order until we run out or one finalizes the response.
-				fiber_pool.spawn do
-				  dispatch_to_handlers(handlers,request,response)
-        end
-				# And finally, if nobody closed the response off, we finalize it.
-				unless response.done
-					response.finished
-				else
-					response.close_connection_after_writing
-				end
-			else
-				# Didn't find it, return a stock 404 response.
-				client.send_data(Const::ERROR_404_RESPONSE)
-				client.close_connection_after_writing
-			end
-		end
-
-		def dispatch_to_handlers(handlers,request,response)
-			handlers.each do |handler|
-				handler.process(request, response)
-				break if response.done
-			end
-		end
-	end
-
-	class HttpRequest
-		def initialize(params, linebuffer, dispatchers)
-			@params = params
-			@dispatchers = dispatchers
-			@body = linebuffer
-		end
-	end
-
-	class HttpResponse
-		def send_file(path, small_file = false)
-			File.open(path, "rb") do |f|
-				while chunk = f.read(Const::CHUNK_SIZE) and chunk.length > 0
-					begin
-						write(chunk)
-					rescue Object => exc
-						break
-					end
-				end
-			end
-			@body_sent = true
-		end
-
-		def write(data)
-			@socket.send_data data
-		end
-
-		def close_connection_after_writing
-			@socket.close_connection_after_writing
-		end
-
-		def socket_error(details)
-			@socket.close_connection
-			done = true
-			raise details
-		end
-
-		def finished
-			send_status
-			send_header
-			send_body
-			@socket.close_connection_after_writing
-		end
-	end
-
-	class Configurator
-		# This version fixes a bug in the regular Mongrel version by adding
-		# initialization of groups.
-		def change_privilege(user, group)
-			if user and group
-				log "Initializing groups for {#user}:{#group}."
-				Process.initgroups(user,Etc.getgrnam(group).gid)
-			end
-
-			if group
-				log "Changing group to #{group}."
-				Process::GID.change_privilege(Etc.getgrnam(group).gid)
-			end
-
-			if user
-				log "Changing user to #{user}."
-				Process::UID.change_privilege(Etc.getpwnam(user).uid)
-			end
-		rescue Errno::EPERM
-			log "FAILED to change user:group #{user}:#{group}: #$!"
-			exit 1
-		end
-	end
-end