neverblock 0.1.6.2

data/README

@@ -0,0 +1,24 @@
+=== Updates from conickal
+Fixes issues brought up with Rails > 2.3.4 and EventMachine > 0.12.10
+
+== 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/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "neverblock"
+    gem.summary = %Q{Utilities for non-blocking stack components}
+    gem.description = %Q{NeverBlock is a collection of classes and modules that help you write evented non-blocking applications in a seemingly blocking mannner.}
+    gem.email = "conickal@gmail.com"
+    gem.homepage = "http://github.com/conickal/neverblock"
+    gem.authors = ["Muhammad A. Ali", "Ahmed Sobhi", "Osama Brekaa", "Nicholas Silva"]
+    gem.add_dependency('eventmachine', '>= 0.12.2')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Dir['tasks/*.rake'].each { |rake| load rake }
+
+task :default => :spec
+

data/VERSION

@@ -0,0 +1 @@
+0.1.6.2

data/lib/active_record/connection_adapters/neverblock_mysql_adapter.rb

@@ -0,0 +1,68 @@
+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:
+    super sql, name
+    id_value || @connection.insert_id
+  end
+
+  def update_sql(sql, name = nil) #:nodoc:
+    super
+    @connection.affected_rows
+  end
+
+  def connect
+    #initialize the connection pool
+    unless @connection
+      @connection = ::NB::DB::PooledDBConnection.new(@connection_options[0]) 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[1..(@connection_options.length-1)])
+        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
+      end
+    else  # we have a connection pool, we need to recover a connection
+      @connection.replace_acquired_connection
+    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,85 @@
+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
+
+      # 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
+        @connection = ::NB::DB::PooledDBConnection.new(@connection_parameters[0]) do
+          conn = ::NB::DB::FiberedPostgresConnection.connect(*@connection_parameters[1..(@connection_parameters.length-1)])
+=begin
+          ::NB::DB::FiberedPostgresConnection.translate_results = false if ::NB::DB::FiberedPostgresConnection.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
+            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
+          end
+	  conn
+=end
+        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.rb

@@ -0,0 +1,102 @@
+# 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__))
+
+# 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?
+  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
+    block.call
+    Fiber.current[:neverblock] = status
+  end
+
+  # Exception to be thrown for all neverblock internal errors
+  class NBError < StandardError
+  end
+
+end
+puts "Using Neverblock"
+NB = NeverBlock

data/lib/never_block/db/fibered_db_connection.rb

@@ -0,0 +1,72 @@
+module NeverBlock
+  module DB
+    module FiberedDBConnection
+
+      # Attaches the connection socket to an event loop and adds a callback
+      # to the fiber's callbacks that unregisters the connection from event loop
+      # Raises NB::NBError
+      def register_with_event_loop
+        #puts ">>>>>register_with_event_loop"
+        if EM.reactor_running?
+          @fiber = Fiber.current
+          #puts ">>>>>register_with_event_loop fiber #{@fiber.inspect}"
+          # When there's no previous em_connection
+          key = em_connection_with_pool_key
+          unless @fiber[key]
+            @fiber[key] = EM::watch(socket,EMConnectionHandler,self) { |c| c.notify_readable = true }
+            @fiber[:callbacks] << self.method(:unregister_from_event_loop)
+            @fiber[:em_keys] << key
+          end
+        else
+          raise ::NB::NBError.new("FiberedDBConnection: EventMachine reactor not running")
+        end
+      end  
+
+      # Unattaches the connection socket from the event loop
+      def unregister_from_event_loop
+        #puts ">>>>>unregister_from_event_loop #{self.inspect} #{@fiber.inspect}"
+        key = @fiber[:em_keys].pop
+        if em_c = @fiber[key]
+          em_c.detach
+          @fiber[key] = nil
+          true
+        else
+          false
+        end
+      end
+
+      # Removes the unregister_from_event_loop callback from the fiber's
+      # callbacks. It should be used when errors occur in an already registered
+      # connection
+      def remove_unregister_from_event_loop_callbacks
+        @fiber[:callbacks].delete self.method(:unregister_from_event_loop)
+      end
+
+      # Closes the connection using event loop
+      def event_loop_connection_close
+        key = em_connection_with_pool_key
+        @fiber[key].close_connection if @fiber[key]
+      end
+           
+      # The callback, this is called whenever
+      # there is data available at the socket
+      def resume_command
+        @fiber.resume if @fiber
+      end
+      
+      private
+      def em_connection_with_pool_key
+        "em_#{@fiber[:current_pool_key]}".intern
+      end
+    end
+    
+    module EMConnectionHandler
+      def initialize connection
+        @db_connection = connection
+      end
+      def notify_readable
+        @db_connection.resume_command
+      end
+    end
+  end
+end

data/lib/never_block/db/fibered_mysql_connection.rb

@@ -0,0 +1,62 @@
+require 'mysqlplus'
+
+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 FiberedMysqlConnection < Mysql	      
+                
+      include FiberedDBConnection
+
+      # 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.event_loop_available? && NB.neverblocking?
+          raise ::NB::NBError.new("FiberedMysqlConnection: The running fiber is attached to a connection other than the current one") if (c = Fiber.current[Fiber.current[:current_pool_key]]) && c != self
+          begin
+            send_query sql
+            Fiber.yield register_with_event_loop
+            get_result
+          rescue Exception => e
+            if error = ['not connected', 'gone away', 'Lost connection'].detect{|msg| e.message.include? msg}
+              event_loop_connection_close
+              unregister_from_event_loop
+              remove_unregister_from_event_loop_callbacks
+              #connect
+            end
+            raise e
+          end
+        else
+          super(sql)
+        end
+      end
+      
+      alias_method :exec, :query
+
+    end #FiberedMySQLConnection
+
+  end #DB
+
+end #NeverBlock
+
+NeverBlock::DB::FMysql = NeverBlock::DB::FiberedMysqlConnection