oldmoe-neverblock 0.1.6 → 1.0

data/lib/never_block.rb

@@ -1,96 +1,23 @@
 # Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
-# Copyright:: Copyright (c) 2008 eSpace, Inc.
+# Copyright:: Copyright (c) 2009 eSpace, Inc.
 # License::   Distributes under the same terms as Ruby
 
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
-# Thanks to Aman Gupta for writing the Ruby 1.8 Fiber simulator
-unless defined? Fiber
-  require 'thread'
-  require 'singleton'
-  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
 
   # Checks if we should be working in a non-blocking mode
   def self.neverblocking?
-    Fiber.respond_to?(:current) && Fiber.current[:neverblock]
-  end
-
-  def self.event_loop_available?
-    defined?(EM) && EM.reactor_running?
+    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 = Fiber.current[:neverblock]
-    Fiber.current[:neverblock] = nb
+    status = NB::Fiber.current[:neverblock]
+    NB::Fiber.current[:neverblock] = nb
     block.call
-    Fiber.current[:neverblock] = status
+    NB::Fiber.current[:neverblock] = status
   end
 
   # Exception to be thrown for all neverblock internal errors

data/lib/neverblock.rb

@@ -5,4 +5,6 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
 require 'never_block'
-
+require 'neverblock/core/reactor'
+require 'neverblock/core/fiber'
+require 'neverblock/core/pool'

data/lib/{never_block/extensions/fiber_extensions.rb → neverblock/core/fiber.rb}

@@ -1,13 +1,18 @@
 # Author::    Mohammad A. Ali  (mailto:oldmoe@gmail.com)
-# Copyright:: Copyright (c) 2008 eSpace, Inc.
+# Copyright:: Copyright (c) 2009 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'
+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
+
 
-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.
@@ -21,6 +26,15 @@ class Fiber
     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

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,50 @@
+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,67 @@
+require 'timeout'
+require File.expand_path(File.dirname(__FILE__)+'/../../../neverblock')
+
+module Timeout
+
+  alias_method :rb_timeout, :timeout
+  
+  def timeout(time, klass=Timeout::Error, &block)
+     return rb_timeout(time, klass,&block) unless NB.neverblocking?
+    if time.nil? || time <= 0
+      block.call
+    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
+        block.call
+      rescue Exception => e
+        raise e        
+      ensure
+        timer.cancel  
+        fiber[:timeouts].pop
+      end
+    end
+  end
+  
+  module_function :timeout  
+  module_function :rb_timeout  
+
+end
+
+NB.reactor.on_add_timer do |timer|
+Kernel.puts "on add"
+  timeouts = NB::Fiber.current[:timeouts]
+  unless timeouts.nil? || timeouts.empty?
+    timeouts.last << timer
+  end
+end
+
+NB.reactor.on_attach do |mode, io|
+   Kernel.puts "on attach"
+  timeouts = NB::Fiber.current[:timeouts]
+  unless timeouts.nil? || timeouts.empty?
+    timeouts.last << [mode, io]
+  end
+end
+
+NB.reactor.on_detach do |mode, io|
+Kernel.puts "on detach"
+  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/{never_block/db/pooled_db_connection.rb → neverblock/io/db/connection.rb}

@@ -1,11 +1,14 @@
+require File.expand_path(File.dirname(__FILE__)+'/pool')
+
 module NeverBlock
+
   module DB
     # a proxy for pooled fibered connections
-    class PooledDBConnection
+    class Connection
       # 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
+        @pool = NB::DB::Pool.new(:size=>size, :eager=>true) do
           yield
         end
       end
@@ -37,7 +40,18 @@ module NeverBlock
         @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,73 @@
+
+require 'mysqlplus'
+require File.expand_path(File.dirname(__FILE__)+'/../../../../neverblock')
+require File.expand_path(File.dirname(__FILE__)+'/../connection')
+require File.expand_path(File.dirname(__FILE__)+'/../fibered_mysql_connection')
+require File.expand_path(File.dirname(__FILE__)+'/../pool')
+
+
+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
+    
+
+