michaelyta-neverblock 1.0

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/never_block.rb

@@ -0,0 +1,29 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2009 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+module NeverBlock
+
+  # Checks if we should be working in a non-blocking mode
+  def self.neverblocking?
+    NB::Fiber.respond_to?(:current) && NB::Fiber.current.respond_to?('[]') && NB::Fiber.current[:neverblock] && NB.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 = NB::Fiber.current[:neverblock]
+    NB::Fiber.current[:neverblock] = nb
+    block.call
+    NB::Fiber.current[:neverblock] = status
+  end
+
+  # Exception to be thrown for all neverblock internal errors
+  class NBError < StandardError
+  end
+
+end
+
+NB = NeverBlock

data/lib/neverblock.rb

@@ -0,0 +1,10 @@
+# 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'
+require 'neverblock/core/reactor'
+require 'neverblock/core/fiber'
+require 'neverblock/core/pool'

data/lib/neverblock/core/fiber.rb

@@ -0,0 +1,45 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2009 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+require 'fiber'
+require File.expand_path(File.dirname(__FILE__)+'/../../never_block')
+
+class NeverBlock::Fiber < Fiber
+
+  def initialize(neverblock = true, &block)
+    self[:neverblock] = neverblock
+    super()
+  end
+
+
+  #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
+  
+  #Sending an exception instance to resume will yield the fiber
+  #and then raise the exception. This is necessary to raise exceptions
+  #in their correct context.
+  def self.yield(*args)
+    result = super
+    raise result if result.is_a? Exception
+    result
+  end
+
+  private
+  
+  def local_fiber_variables
+    @local_fiber_variables ||= {}
+  end
+
+end
+

data/lib/neverblock/core/pool.rb

@@ -0,0 +1,72 @@
+
+require File.expand_path(File.dirname(__FILE__)+'/fiber')
+
+module NeverBlock
+  # 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::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 = NB::Fiber.new do |block|
+          loop do
+            block.call
+            # callbacks are called in a reverse order, much like c++ destructor
+            NB::Fiber.current[:callbacks].pop.call while NB::Fiber.current[:callbacks].length > 0
+            unless @queue.empty?
+              block = @queue.shift
+            else
+              @busy_fibers.delete(NB::Fiber.current.object_id)
+              @fibers << NB::Fiber.current
+              block = NB::Fiber.yield
+            end
+          end
+        end
+        fiber[:callbacks] = []
+        @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 # NeverBlock
+

data/lib/neverblock/core/reactor.rb

@@ -0,0 +1,52 @@
+$:.unshift 
+
+require 'reactor'
+require 'thread'
+require File.expand_path(File.dirname(__FILE__)+'/fiber')
+
+module NeverBlock
+
+  @@reactors = {}
+
+  @@queue = Queue.new
+
+  @@thread_pool = []
+
+  20.times do
+    @@thread_pool << Thread.new do
+      loop do
+        io, method, params, fiber, reactor = *(@@queue.shift)
+        begin
+          reactor.next_tick{fiber.resume(io.__send__(method, *params))} if fiber.alive? 
+        rescue Exception => e
+          reactor.next_tick{fiber.resume(e)} if fiber.alive?          
+        end
+      end
+    end
+  end
+
+  def self.reactor
+    @@reactors[Thread.current.object_id] ||= ::Reactor::Base.new
+  end
+
+  def self.wait(mode, io)
+    fiber = NB::Fiber.current
+    NB.reactor.attach(mode, io){fiber.resume}
+    NB::Fiber.yield
+    NB.reactor.detach(mode, io)
+  end
+
+  def self.sleep(time)
+    NB::Fiber.yield if time.nil?
+    return if time <= 0 
+    fiber = NB::Fiber.current
+    NB.reactor.add_timer(time){fiber.resume}
+    NB::Fiber.yield
+  end
+
+  def self.defer(io, action, args)
+    @@queue << [io, action, args, NB::Fiber.current, NB.reactor]
+    NB::Fiber.yield      
+  end
+
+end

data/lib/neverblock/core/system/system.rb

@@ -0,0 +1,38 @@
+
+require File.expand_path(File.dirname(__FILE__)+'/../../../neverblock')
+
+module Kernel
+
+  alias_method :rb_sleep, :sleep
+
+  def sleep(time=nil)
+    return rb_sleep(time) unless NB.neverblocking?
+    NB.sleep(time)
+  end
+
+  alias_method :rb_system, :system
+
+  def system(cmd, *args)
+    return rb_system(cmd, *args) unless NB.neverblocking?
+    begin
+      backticks(cmd, *args)
+      result = $?.exitstatus
+      return true if result.zero?
+      return nil if result == 127
+      return false
+    rescue Errno::ENOENT => e
+      return nil
+    end
+  end
+
+  def backticks(cmd, *args)
+    myargs = "#{cmd} "
+    myargs << args.join(' ') if args
+    res = ''    
+    IO.popen(myargs) do |f|
+      res << f.read
+    end
+    res
+  end
+  
+end

data/lib/neverblock/core/system/timeout.rb

@@ -0,0 +1,60 @@
+require 'timeout'
+require File.expand_path(File.dirname(__FILE__)+'/../../../neverblock')
+
+module Timeout
+
+  alias_method :rb_timeout, :timeout
+  
+  def timeout(time, klass=Timeout::Error)
+    return rb_timeout(time, klass) unless NB.neverblocking?
+    if time.nil? || time <= 0
+      yield
+    else
+      fiber = NB::Fiber.current
+      timer = NB.reactor.add_timer(time) do 
+        fiber[:timeouts].last.each do |event|
+          if event.is_a? Reactor::Timer
+            event.cancel
+          else
+            NB.reactor.detach(event[0], event[1])
+          end
+        end
+        fiber.resume(klass.new)
+      end
+      (fiber[:timeouts] ||= []) << []
+      begin
+        yield
+      rescue Exception => e
+        raise e        
+      ensure
+        timer.cancel  
+        fiber[:timeouts].pop
+      end
+    end
+  end
+  
+  module_function :timeout  
+
+end
+
+NB.reactor.on_add_timer do |timer|
+  timeouts = NB::Fiber.current[:timeouts]
+  unless timeouts.nil? || timeouts.empty?
+    timeouts.last << timer
+  end
+end
+
+NB.reactor.on_attach do |mode, io|
+  timeouts = NB::Fiber.current[:timeouts]
+  unless timeouts.nil? || timeouts.empty?
+    timeouts.last << [mode, io]
+  end
+end
+
+NB.reactor.on_detach do |mode, io|
+  timeouts = NB::Fiber.current[:timeouts]
+  unless timeouts.nil? || timeouts.empty?
+    timeouts.delete_if{|to|to.is_a? Array && to[0] == mode && to[1] == io}
+  end
+end
+

data/lib/neverblock/io/db/connection.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__)+'/pool')
+
+module NeverBlock
+
+  module DB
+    # a proxy for pooled fibered connections
+    class Connection
+      # Requires a block with connection parameters
+      # and a pool size (defaults to 4)
+      def initialize(size=4, &block)
+        @pool = NB::DB::Pool.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
+
+      protected
+      
+      # are we in a transaction?
+      # if no then just hold a connection and run the block
+      # else get a connection, pass it to the block
+      # and move away     
+      def hold_connection
+      
+      end      
+      
+    end
+  end
+end

data/lib/neverblock/io/db/drivers/mysql.rb

@@ -0,0 +1,69 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'mysqlplus'
+require 'neverblock/db/connection'
+
+module NeverBlock
+
+  module DB
+    # 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 Mysql < ::Mysql
+                
+      # 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)
+        if NB.neverblocking? && NB.reactor.running?
+          send_query sql
+          NB.wait(:read, IO.new(socket))
+          get_result
+        else
+          super(sql)
+        end
+      end
+      
+      alias_method :exec, :query
+
+    end #MySQL
+
+    class PooledMySQL < ::NeverBlock::DB::Connection
+
+      def initialize(*args)
+        options = {}
+        if args && (options = args.last).is_a? Hash
+          size = options[:size] || 4
+          eager = options[:eager] || true
+          args.pop
+        end
+        @pool = NB::DB::Pool.new(:size=>size, :eager=>eager) do
+          MySQL.new(*args)
+        end
+      end
+
+    end #PooledMySQL
+
+  end #DB
+
+end #NeverBlock
+    
+
+

data/lib/neverblock/io/db/drivers/postgres.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__)+'/pg')
+require File.expand_path(File.dirname(__FILE__)+'/../connection')
+
+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 (Reacotr)
+    # and then whenever the query is executed
+    # within the scope of a friendly fiber (NB::Fiber)
+    # it will be done in async mode and the fiber
+    # will yield
+	  class Postgres < PGconn	                    
+
+      # 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.neverblocking? && NB.reactor.running?
+          send_query sql
+          while is_busy
+            NB.wait(:read, IO.new(socket))
+            consume_input
+          end
+          res, data = 0, []
+          while res != nil
+            res = self.get_result
+            data << res unless res.nil?
+          end
+          data.last
+        else
+          super(sql)
+        end
+      end
+
+      alias_method :query, :exec
+            
+    end #Postgres 
+
+    class PooledPostgres < ::NeverBlock::DB::Connection
+
+      def initialize(*args)
+        options = {}
+        if args && (options = args.last).is_a? Hash
+          size = options[:size] || 4
+          eager = options[:eager] || true
+          args.pop
+        end
+        @pool = NB::DB::Pool.new(:size=>size, :eager=>eager) do
+          Postgres.new(*args)
+        end
+      end
+
+    end #PooledMySQL
+  end #DB
+
+end #NeverBlock

data/lib/neverblock/io/db/pool.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.dirname(__FILE__)+'/../../../neverblock')
+
+module NeverBlock
+  module DB
+		# 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.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
+    # 
+    # It is the responsibility of client code to release the connection
+    # using pool.release(conn)
+		class Pool
+
+      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 = NB::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 = NB::Fiber.current
+        conn = acquire(fiber)
+        if block_given?
+          yield conn
+          release(conn)
+        else
+          conn
+        end
+			end
+
+      # Give the fiber's connection back to the pool
+			def release(conn)
+			  @busy_connections.delete(conn.object_id)
+			  @connections << conn unless @connections.include? conn
+        process_queue
+			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)
+        conn =  if !@connections.empty?
+          @connections.shift
+        elsif (@connections.length + @busy_connections.length) < @size
+          @connection_proc.call
+        else
+					NB::Fiber.yield @queue << fiber
+        end
+        @busy_connections[conn.object_id] = conn
+			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
+						
+		end #FiberedConnectionPool
+		
+	end #Pool
+
+end #NeverBlock

data/lib/neverblock/io/file.rb

@@ -0,0 +1,24 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2009 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+require 'thread'
+require File.expand_path(File.dirname(__FILE__)+'/io')
+
+class File < IO
+  
+  def self.neverblock(*methods)
+    methods.each do |method|  
+      class_eval %{
+        def #{method}(*args)
+          return rb_#{method}(*args) unless NB.neverblocking?
+          NB.defer(self, :#{method}, args)
+        end
+      }
+    end
+  end
+  
+  neverblock :syswrite, :sysread, :write, :read, :readline, 
+             :readlines, :readchar, :gets, :getc, :print
+               
+end

data/lib/neverblock/io/io.rb

@@ -0,0 +1,219 @@
+require 'fcntl'
+
+# This is an extention to the Ruby IO class that makes it compatable with
+#	NeverBlocks event loop to avoid blocking IO calls. That's done by delegating
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2009 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+$:.unshift 
+
+require File.expand_path(File.dirname(__FILE__)+'/../../neverblock')
+
+class IO
+
+	NB_BUFFER_LENGTH = 128*1024
+	
+  alias_method :rb_sysread,   :sysread
+  alias_method :rb_syswrite,  :syswrite
+  alias_method :rb_read,      :read
+  alias_method :rb_write,     :write
+  alias_method :rb_gets,      :gets
+  alias_method :rb_getc,      :getc
+  alias_method :rb_readchar,  :readchar
+  alias_method :rb_readline,  :readline
+  alias_method :rb_readlines, :readlines
+  alias_method :rb_print,     :print
+  
+	#	This method is the delegation method which reads using read_nonblock()
+	#	and registers the IO call with event loop if the call blocks. The value
+	# @immediate_result is used to get the value that method got before it was blocked.
+
+  def read_neverblock(*args)
+		res = ""
+		begin
+      old_flags = get_flags			
+			res << read_nonblock(*args)
+      set_flags(old_flags)
+		rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+      set_flags(old_flags)
+  		NB.wait(:read, self)
+  		retry
+		end
+		res
+  end
+
+	#	The is the main reading method that all other methods use.
+	#	If the mode is set to neverblock it uses the delegation method.
+	#	Otherwise it uses the original ruby read method.
+
+  def sysread(length)
+    self.neverblock? ? read_neverblock(length) : rb_sysread(length)
+  end
+  
+  def read(length=nil, sbuffer=nil)
+    return rb_read(length, sbuffer) if self.file?
+    return '' if length == 0
+    if sbuffer.nil?
+      sbuffer = '' 
+    else
+     sbuffer = sbuffer.to_str
+     sbuffer.delete!(sbuffer)
+    end    
+    if length.nil?
+      # we need to read till end of stream
+      loop do
+        begin 
+          sbuffer << sysread(NB_BUFFER_LENGTH)
+        rescue EOFError
+      	  break
+        end
+      end
+      return sbuffer 
+    else # length != nil
+      if self.buffer.length >= length
+        sbuffer << self.buffer.slice!(0, length)
+        return sbuffer
+      elsif self.buffer.length > 0
+        sbuffer << self.buffer
+      end
+      self.buffer = ''
+      remaining_length = length - sbuffer.length
+	    while sbuffer.length < length && remaining_length > 0 
+		    begin 
+			    sbuffer << sysread(NB_BUFFER_LENGTH < remaining_length ? remaining_length : NB_BUFFER_LENGTH)
+          remaining_length = remaining_length - sbuffer.length   
+		    rescue EOFError
+          break
+		    end #begin
+	    end	#while	  
+    end #if length 
+    return nil if sbuffer.length.zero? && length > 0
+    return sbuffer if sbuffer.length <= length
+		self.buffer << sbuffer.slice!(length, sbuffer.length-1)
+    return sbuffer
+  end
+
+ def readpartial(length=nil,sbuffer=nil)
+   raise ArgumentError if !length.nil? && length < 0
+    if sbuffer.nil?
+      sbuffer = '' 
+    else
+     sbuffer = sbuffer.to_str
+     sbuffer.delete!(sbuffer)
+    end
+   
+    if self.buffer.length >= length
+       sbuffer << self.buffer.slice!(0, length)
+    elsif self.buffer.length > 0 
+      sbuffer << self.buffer.slice!(0, self.buffer.length-1)
+    else
+      sbuffer << rb_sysread(length)
+    end  
+     return sbuffer  
+  end
+
+  def write_neverblock(data)
+		written = 0
+		begin
+      old_flags = get_flags			
+			written = written + write_nonblock(data[written,data.length])
+      set_flags(old_flags)
+			raise Errno::EAGAIN if written < data.length
+		rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+      set_flags(old_flags)
+  		NB.wait(:write, self)
+			retry
+	  end
+		written
+  end
+
+	def syswrite(*args)	
+		return rb_syswrite(*args) unless self.neverblock?
+			write_neverblock(*args)
+	end
+  
+	def write(data)
+    return 0 if data.to_s.empty?
+    return rb_write(data) if self.file?
+		syswrite(data)
+	end 
+	
+	def gets(sep=$/)
+    return rb_gets(sep) if self.file?
+		res = ""
+		sep = "\n\n" if sep == ""
+		sep = $/ if sep.nil?
+		while res.index(sep).nil?
+		  break if (c = read(1)).nil?
+		  res << c
+		end
+		$_ = res
+		res
+	end
+	
+	def readlines(sep=$/)
+    return rb_readlines(sep) if self.file?
+		res = []
+		begin
+			loop{res << readline(sep)}
+		rescue EOFError
+		end
+		res
+	end
+	
+	def readchar
+    return rb_readchar if self.file?
+		ch = read(1)
+		raise EOFError if ch.nil?
+		ch
+	end
+	
+	def getc
+    return rb_getc if self.file?
+		begin
+			res = readchar
+		rescue EOFError
+			res = nil
+		end
+	end
+
+	def readline(sep = $/)
+    return rb_readline(sep) if self.file?
+		res = gets(sep)
+		raise EOFError if res == nil
+		res
+	end
+	
+	def print(*args)
+    return rb_print if self.file?
+		args.each{|element|syswrite(element)}
+	end
+
+	protected
+
+  def get_flags
+    self.fcntl(Fcntl::F_GETFL, 0)
+  end
+
+  def set_flags(flags)
+    self.fcntl(Fcntl::F_SETFL, flags)
+  end
+
+	def buffer
+	 @buffer ||= ""
+	end		
+
+	def buffer=(value)
+	 @buffer = value
+	end		
+	
+	def file?
+	  @file ||= self.stat.file?
+	end
+
+  def neverblock?
+    !file? && NB.neverblocking?
+	end	
+
+end

data/lib/neverblock/io/socket.rb

@@ -0,0 +1,75 @@
+# Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
+# Copyright:: Copyright (c) 2009 eSpace, Inc.
+# License::   Distributes under the same terms as Ruby
+
+require 'socket'
+require 'fcntl'
+require File.expand_path(File.dirname(__FILE__)+'/io')
+
+class BasicSocket < IO
+
+  @@getaddress_method = IPSocket.method(:getaddress)
+  def self.getaddress(*args)
+    @@getaddress_method.call(*args)
+  end
+
+  alias_method :recv_blocking, :recv
+
+	def recv_neverblock(*args)
+		res = ""
+		begin
+      old_flags = self.fcntl(Fcntl::F_GETFL, 0)
+			res << recv_nonblock(*args)
+      self.fcntl(Fcntl::F_SETFL, old_flags)
+		rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+      self.fcntl(Fcntl::F_SETFL, old_flags)
+  		NB.wait(:read, self)
+  		retry
+		end
+		res
+  end
+
+	def recv(*args)
+		if NB.neverblocking?
+			recv_neverblock(*args)
+    else
+      recv_blocking(*args)
+    end
+  end
+
+end
+
+class Socket < BasicSocket
+  
+	alias_method :connect_blocking, :connect
+	    
+  def connect_neverblock(server_sockaddr)
+    begin
+      connect_nonblock(server_sockaddr)
+    rescue Errno::EINPROGRESS, Errno::EINTR, Errno::EALREADY, Errno::EWOULDBLOCK
+      NB.wait(:write, self)
+			retry
+    rescue Errno::EISCONN
+      # do nothing, we are good
+    end
+  end
+    
+  def connect(server_sockaddr)
+    if NB.neverblocking?
+	  	connect_neverblock(server_sockaddr)
+    else
+      connect_blocking(server_sockaddr)
+    end
+  end
+
+end
+
+Object.send(:remove_const, :TCPSocket)
+
+class TCPSocket < Socket
+	def initialize(*args)
+    super(AF_INET, SOCK_STREAM, 0)
+    self.connect(Socket.sockaddr_in(*(args.reverse)))
+  end
+end
+

data/lib/neverblock_io.rb

@@ -0,0 +1,6 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'neverblock'
+#socket and file will require IO.rb in core
+require 'neverblock/io/socket'
+require 'neverblock/io/file'

data/lib/system.rb

@@ -0,0 +1,4 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'neverblock/core/system/system'
+require 'neverblock/core/system/timeout'

data/neverblock.gemspec

@@ -0,0 +1,37 @@
+Gem::Specification.new do |s|
+  s.name     = "neverblock"
+  s.version  = "1.0"
+  s.date     = "2009-07-16"
+  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/core/reactor.rb",
+                "lib/neverblock/core/fiber.rb",
+                "lib/neverblock/core/pool.rb",
+                "lib/neverblock/core/system/system.rb",
+                "lib/neverblock/core/system/timeout.rb",
+                "lib/neverblock/io/db/pool.rb",
+                "lib/neverblock/io/db/drivers/mysql.rb",
+                "lib/neverblock/io/db/drivers/postgres.rb",
+                "lib/neverblock/io/db/connection.rb",
+                "lib/neverblock/io/file.rb",
+                "lib/neverblock/io/socket.rb",
+                "lib/neverblock/io/io.rb",
+                "lib/system.rb",
+                "lib/neverblock.rb",
+                "lib/never_block.rb",
+                "lib/neverblock_io.rb"
+
+  ]
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.add_dependency('reactor', '>= 0.2.3')
+end
+
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: michaelyta-neverblock
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Muhammad A. Ali
+- Ahmed Sobhi
+- Osama Brekaa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: reactor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    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: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- neverblock.gemspec
+- README
+- lib/neverblock/core/reactor.rb
+- lib/neverblock/core/fiber.rb
+- lib/neverblock/core/pool.rb
+- lib/neverblock/core/system/system.rb
+- lib/neverblock/core/system/timeout.rb
+- lib/neverblock/io/db/pool.rb
+- lib/neverblock/io/db/drivers/mysql.rb
+- lib/neverblock/io/db/drivers/postgres.rb
+- lib/neverblock/io/db/connection.rb
+- lib/neverblock/io/file.rb
+- lib/neverblock/io/socket.rb
+- lib/neverblock/io/io.rb
+- lib/system.rb
+- lib/neverblock.rb
+- lib/never_block.rb
+- lib/neverblock_io.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: []
+