cool.io 1.0.0 → 1.9.0

data/lib/cool.io/io.rb

@@ -15,13 +15,13 @@ module Coolio
   # Socket class and its associated subclasses.
   class IO
     extend Meta
-    
+
     # Maximum number of bytes to consume at once
     INPUT_SIZE = 16384
 
     def initialize(io)
       @_io = io
-      @_write_buffer  ||= ::IO::Buffer.new
+      @_write_buffer  ||= ::Coolio::Buffer.new
       @_read_watcher  = Watcher.new(io, self, :r)
       @_write_watcher = Watcher.new(io, self, :w)
     end
@@ -29,32 +29,52 @@ module Coolio
     #
     # Watcher methods, delegated to @_read_watcher
     #
-    
+
     # Attach to the event loop
-    def attach(loop); @_read_watcher.attach loop; schedule_write if !@_write_buffer.empty?; self; end
-    
+    def attach(loop)
+      @_read_watcher.attach(loop)
+      schedule_write if !@_write_buffer.empty?
+      self
+    end
+
     # Detach from the event loop
-    def detach; @_read_watcher.detach; self; end # TODO should these detect write buffers, as well?
-    
+    def detach
+      # TODO should these detect write buffers, as well?
+      @_read_watcher.detach
+      self
+    end
+
     # Enable the watcher
-    def enable; @_read_watcher.enable; self; end
-    
+    def enable
+      @_read_watcher.enable
+      self
+    end
+
     # Disable the watcher
-    def disable; @_read_watcher.disable; self; end
-    
+    def disable
+      @_read_watcher.disable
+      self
+    end
+
     # Is the watcher attached?
-    def attached?; @_read_watcher.attached?; end
-    
+    def attached?
+      @_read_watcher.attached?
+    end
+
     # Is the watcher enabled?
-    def enabled?; @_read_watcher.enabled?; end
-    
+    def enabled?
+      @_read_watcher.enabled?
+    end
+
     # Obtain the event loop associated with this object
-    def evloop; @_read_watcher.evloop; end
-    
+    def evloop
+      @_read_watcher.evloop
+    end
+
     #
     # Callbacks for asynchronous events
     #
-      
+
     # Called whenever the IO object receives data
     def on_read(data); end
     event_callback :on_read
@@ -78,16 +98,11 @@ module Coolio
       data.size
     end
 
-    # Number of bytes are currently in the output buffer
-    def output_buffer_size
-      @_write_buffer.size
-    end
-
     # Close the IO stream
     def close
       detach if attached?
       detach_write_watcher
-      @_io.close unless @_io.closed?
+      @_io.close unless closed?
 
       on_close
       nil
@@ -114,7 +129,7 @@ module Coolio
         close
       end
     end
-    
+
     # Write the contents of the output buffer
     def on_writable
       begin
@@ -126,23 +141,23 @@ module Coolio
       rescue SystemCallError, IOError, SocketError
         return close
       end
-      
+
       if @_write_buffer.empty?
         disable_write_watcher
         on_write_complete
       end
     end
 
-    # Schedule a write to be performed when the IO object becomes writable 
+    # Schedule a write to be performed when the IO object becomes writable
     def schedule_write
       return unless @_io # this would mean 'we are still pre DNS here'
-      return unless attached? # this would mean 'currently unattached' -- ie still pre DNS, or just plain not attached, which is ok
+      return unless @_read_watcher.attached? # this would mean 'currently unattached' -- ie still pre DNS, or just plain not attached, which is ok
       begin
-        enable_write_watcher      
+        enable_write_watcher
       rescue IOError
       end
     end
-    
+
     def enable_write_watcher
       if @_write_watcher.attached?
         @_write_watcher.enable unless @_write_watcher.enabled?
@@ -150,15 +165,15 @@ module Coolio
         @_write_watcher.attach(evloop)
       end
     end
-    
+
     def disable_write_watcher
       @_write_watcher.disable if @_write_watcher and @_write_watcher.enabled?
     end
-    
+
     def detach_write_watcher
       @_write_watcher.detach if @_write_watcher and @_write_watcher.attached?
     end
-    
+
     # Internal class implementing watchers used by Coolio::IO
     class Watcher < IOWatcher
       def initialize(ruby_io, coolio_io, flags)
@@ -167,8 +182,13 @@ module Coolio
       end
 
       # Configure IOWatcher event callbacks to call the method passed to #initialize
-      def on_readable; @coolio_io.__send__(:on_readable); end
-      def on_writable; @coolio_io.__send__(:on_writable); end
+      def on_readable
+        @coolio_io.__send__(:on_readable)
+      end
+
+      def on_writable
+        @coolio_io.__send__(:on_writable)
+      end
     end
   end
 end

data/lib/cool.io/iowatcher.rb

@@ -5,7 +5,7 @@
 #++
 
 module Coolio
-  class IOWatcher 
+  class IOWatcher
     # The actual implementation of this class resides in the C extension
     # Here we metaprogram proper event_callbacks for the callback methods
     # These can take a block and store it to be called when the event

data/lib/cool.io/listener.rb

@@ -21,6 +21,10 @@ module Coolio
       @listen_socket.fileno
     end
 
+    def listen(backlog)
+      @listen_socket.listen(backlog)
+    end
+
     # Close the listener
     def close
       detach if attached?
@@ -36,26 +40,38 @@ module Coolio
     #########
 
     # Coolio callback for handling new connections
-    def on_readable
-      begin
-        on_connection @listen_socket.accept_nonblock
-      rescue Errno::EAGAIN, Errno::ECONNABORTED
-        # EAGAIN can be triggered here if the socket is shared between
-        # multiple processes and a thundering herd is woken up to accept
-        # one connection, only one process will get the connection and
-        # the others will be awoken.
-        # ECONNABORTED is documented in accept() manpages but modern TCP
-        # stacks with syncookies and/or accept()-filtering for DoS
-        # protection do not see it.  In any case this error is harmless
-        # and we should instead spend our time with clients that follow
-        # through on connection attempts.
+    unless RUBY_PLATFORM =~ /mingw|mswin/
+      def on_readable
+        begin
+          on_connection @listen_socket.accept_nonblock
+        rescue Errno::EAGAIN, Errno::ECONNABORTED
+          # EAGAIN can be triggered here if the socket is shared between
+          # multiple processes and a thundering herd is woken up to accept
+          # one connection, only one process will get the connection and
+          # the others will be awoken.
+          # ECONNABORTED is documented in accept() manpages but modern TCP
+          # stacks with syncookies and/or accept()-filtering for DoS
+          # protection do not see it.  In any case this error is harmless
+          # and we should instead spend our time with clients that follow
+          # through on connection attempts.
+        end
+      end
+    else
+      def on_readable
+        begin
+          # In Windows, accept_nonblock() with multiple processes
+          # causes thundering herd problem.
+          # To avoid this, we need to use accept().
+          on_connection @listen_socket.accept
+        rescue Errno::EAGAIN, Errno::ECONNABORTED
+        end
       end
     end
   end
 
+  DEFAULT_BACKLOG = 1024
+
   class TCPListener < Listener
-    DEFAULT_BACKLOG = 1024
-    
     # Create a new Coolio::TCPListener on the specified address and port.
     # Accepts the following options:
     #
@@ -68,7 +84,7 @@ module Coolio
     def initialize(addr, port = nil, options = {})
       BasicSocket.do_not_reverse_lookup = true unless options[:reverse_lookup]
       options[:backlog] ||= DEFAULT_BACKLOG
-      
+
       listen_socket = if ::TCPServer === addr
         addr
       else
@@ -87,7 +103,9 @@ module Coolio
     # Optionally, it can also take anyn existing UNIXServer object
     # and create a Coolio::UNIXListener out of it.
     def initialize(*args)
-      super(::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args))
+      s = ::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
+      super(s)
     end
   end
 end

data/lib/cool.io/loop.rb

@@ -15,17 +15,9 @@ end
 
 module Coolio
   class Loop
-    # In Ruby 1.9 we want a Coolio::Loop per thread, but Ruby 1.8 is unithreaded
-    if RUBY_VERSION >= "1.9.0"
-      # Retrieve the default event loop for the current thread
-      def self.default
-        Thread.current._coolio_loop
-      end
-    else
-      # Retrieve the default event loop
-      def self.default
-        @@_coolio_loop ||= Coolio::Loop.new
-      end
+    # Retrieve the default event loop for the current thread
+    def self.default
+      Thread.current._coolio_loop
     end
 
     # Create a new Coolio::Loop
@@ -35,7 +27,7 @@ module Coolio
     # :skip_environment (boolean)
     #   Ignore the $LIBEV_FLAGS environment variable
     #
-    # :fork_check (boolean)      
+    # :fork_check (boolean)
     #   Enable autodetection of forks
     #
     # :backend
@@ -49,7 +41,7 @@ module Coolio
     def initialize(options = {})
       @watchers = {}
       @active_watchers = 0
-      
+
       flags = 0
 
       options.each do |option, value|
@@ -76,7 +68,7 @@ module Coolio
 
       @loop = ev_loop_new(flags)
     end
-    
+
     # Attach a watcher to the loop
     def attach(watcher)
       watcher.attach self
@@ -86,14 +78,14 @@ module Coolio
     # are no watchers associated with the event loop it will return
     # immediately.  Otherwise, run will continue blocking and making
     # event callbacks to watchers until all watchers associated with
-    # the loop have been disabled or detached.  The loop may be 
+    # the loop have been disabled or detached.  The loop may be
     # explicitly stopped by calling the stop method on the loop object.
-    def run
+    def run(timeout = nil)
       raise RuntimeError, "no watchers for this loop" if @watchers.empty?
 
       @running = true
       while @running and not @active_watchers.zero?
-        run_once
+        run_once(timeout)
       end
       @running = false
     end
@@ -103,28 +95,28 @@ module Coolio
       raise RuntimeError, "loop not running" unless @running
       @running = false
     end
-    
+
     # Does the loop have any active watchers?
     def has_active_watchers?
       @active_watchers > 0
     end
-    
+
     # All watchers attached to the current loop
     def watchers
       @watchers.keys
     end
-    
+
     #######
     private
     #######
-    
+
     EVFLAG_NOENV     = 0x1000000  # do NOT consult environment
     EVFLAG_FORKCHECK = 0x2000000  # check for a fork in each iteration
 
-    EVBACKEND_SELECT = 0x00000001 # supported about anywhere 
-    EVBACKEND_POLL   = 0x00000002 # !win 
-    EVBACKEND_EPOLL  = 0x00000004 # linux 
-    EVBACKEND_KQUEUE = 0x00000008 # bsd 
+    EVBACKEND_SELECT = 0x00000001 # supported about anywhere
+    EVBACKEND_POLL   = 0x00000002 # !win
+    EVBACKEND_EPOLL  = 0x00000004 # linux
+    EVBACKEND_KQUEUE = 0x00000008 # bsd
     EVBACKEND_PORT   = 0x00000020 # solaris 10
   end
 end

data/lib/cool.io/meta.rb

@@ -11,10 +11,10 @@ module Coolio
     # an event to occur before the current watcher can be used in earnest,
     # such as making an outgoing TCP connection.
     def watcher_delegate(proxy_var)
-      %w{attach detach enable disable}.each do |method|
+      %w{attach attached? detach enable disable}.each do |method|
         module_eval <<-EOD
           def #{method}(*args)
-            if #{proxy_var}
+            if defined? #{proxy_var} and #{proxy_var}
               #{proxy_var}.#{method}(*args)
               return self
             end
@@ -32,14 +32,15 @@ module Coolio
     def event_callback(*methods)
       methods.each do |method|
         module_eval <<-EOD
+          remove_method "#{method}"
           def #{method}(*args, &block)
             if block
               @#{method}_callback = block
               return
             end
-            
-            if @#{method}_callback
-              instance_exec(*args, &@#{method}_callback) 
+
+            if defined? @#{method}_callback and @#{method}_callback
+              @#{method}_callback.call(*args)
             end
           end
         EOD

data/lib/cool.io/server.rb

@@ -20,9 +20,9 @@ module Coolio
       expected = arity >= 0 ? arity : -(arity + 1)
 
       if (arity >= 0 and args.size + 1 != expected) or (arity < 0 and args.size + 1 < expected)
-        raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size+1} for #{expected})" 
+        raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size+1} for #{expected})"
       end
-     
+
       @klass, @args, @block = klass, args, block
       super(listen_socket)
     end
@@ -35,7 +35,7 @@ module Coolio
     #########
     protected
     #########
-    
+
     def on_connection(socket)
       connection = @klass.new(socket, *@args).attach(evloop)
       connection.__send__(:on_connect)
@@ -56,7 +56,7 @@ module Coolio
         raise ArgumentError, "port must be an integer" if nil == port
         ::TCPServer.new(host, port)
       end
-      listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
+      listen_socket.instance_eval { listen(DEFAULT_BACKLOG) } # Change listen backlog to 1024
       super(listen_socket, klass, *args, &block)
     end
   end
@@ -68,6 +68,7 @@ module Coolio
   class UNIXServer < Server
     def initialize(path, klass = UNIXSocket, *args, &block)
       s = ::UNIXServer === path ? path : ::UNIXServer.new(path)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
       super(s, klass, *args, &block)
     end
   end

data/lib/cool.io/socket.rb

@@ -8,7 +8,7 @@ require 'socket'
 require 'resolv'
 
 module Coolio
-  class Socket < IO    
+  class Socket < IO
     def self.connect(socket, *args)
 
       new(socket, *args).instance_eval do
@@ -16,42 +16,51 @@ module Coolio
         self
       end
     end
-    
+
+    # Just initializes some instance variables to avoid
+    # warnings and calls super().
+    def initialize *args
+      @_failed = nil
+      @_connector = nil
+      super
+    end
+
     watcher_delegate :@_connector
 
+    remove_method :attach
     def attach(evloop)
       raise RuntimeError, "connection failed" if @_failed
-      
+
       if @_connector
         @_connector.attach(evloop)
         return self
       end
-      
+
       super
     end
 
     # Called upon completion of a socket connection
     def on_connect; end
     event_callback :on_connect
-    
+
     # Called if a socket connection failed to complete
     def on_connect_failed; end
     event_callback :on_connect_failed
-    
+
     # Called if a hostname failed to resolve when connecting
     # Defaults to calling on_connect_failed
     alias_method :on_resolve_failed, :on_connect_failed
-    
+
     #########
     protected
     #########
-    
+
     class Connector < IOWatcher
       def initialize(coolio_socket, ruby_socket)
         @coolio_socket, @ruby_socket = coolio_socket, ruby_socket
         super(ruby_socket, :w)
       end
-      
+
       def on_writable
         evl = evloop
         detach
@@ -67,7 +76,7 @@ module Coolio
           @coolio_socket.instance_eval { @_failed = true }
           @coolio_socket.__send__(:on_connect_failed)
         end
-      end      
+      end
 
       #######
       private
@@ -80,11 +89,11 @@ module Coolio
       end
     end
   end
-  
+
   class TCPSocket < Socket
     attr_reader :remote_host, :remote_addr, :remote_port, :address_family
     watcher_delegate :@_resolver
-    
+
     # Similar to .new, but used in cases where the resulting object is in a
     # "half-open" state.  This is primarily used for when asynchronous
     # DNS resolution is taking place.  We don't actually have a handle to
@@ -95,7 +104,7 @@ module Coolio
       obj.__send__(:preinitialize, *args, &block)
       obj
     end
-    
+
     # Perform a non-blocking connect to the given host and port
     # see examples/echo_client.rb
     # addr is a string, can be an IP address or a hostname.
@@ -107,7 +116,7 @@ module Coolio
       elsif(Resolv::IPv6.create(addr) rescue nil)
         family = ::Socket::AF_INET6
       end
- 
+
       if family
         return super(TCPConnectSocket.new(family, addr, port), *args) # this creates a 'real' write buffer so we're ok there with regards to already having a write buffer from the get go
       end
@@ -118,37 +127,39 @@ module Coolio
 
       precreate(addr, port, *args)
     end
-    
+
     # Called by precreate during asyncronous DNS resolution
     def preinitialize(addr, port, *args)
-      @_write_buffer = ::IO::Buffer.new # allow for writing BEFORE DNS has resolved
+      @_write_buffer = ::Coolio::Buffer.new # allow for writing BEFORE DNS has resolved
       @remote_host, @remote_addr, @remote_port = addr, addr, port
       @_resolver = TCPConnectResolver.new(self, addr, port, *args)
     end
-    
+
     private :preinitialize
-    
+
+    PEERADDR_FAILED = ["?", 0, "name resolusion failed", "?"]
+
     def initialize(socket)
       unless socket.is_a?(::TCPSocket) or socket.is_a?(TCPConnectSocket)
         raise TypeError, "socket must be a TCPSocket"
       end
-      
+
       super
-      
-      @address_family, @remote_port, @remote_host, @remote_addr = socket.peeraddr
+
+      @address_family, @remote_port, @remote_host, @remote_addr = (socket.peeraddr rescue PEERADDR_FAILED)
     end
-    
+
     def peeraddr
       [@address_family, @remote_port, @remote_host, @remote_addr]
     end
-    
+
     #########
     protected
     #########
 
     class TCPConnectSocket < ::Socket
       def initialize(family, addr, port, host = addr)
-        @host,  addr, @port = host, addr, port
+        @host, @addr, @port = host, addr, port
         @address_family = nil
 
         super(family, ::Socket::SOCK_STREAM, 0)
@@ -195,26 +206,26 @@ module Coolio
 
       def on_failure
         @sock.__send__(:on_resolve_failed)
-        @sock.instance_eval do 
-          @_resolver = nil 
+        @sock.instance_eval do
+          @_resolver = nil
           @_failed = true
         end
         return
       end
     end
   end
-  
+
   class UNIXSocket < Socket
     attr_reader :path, :address_family
-    
+
     # Connect to the given UNIX domain socket
     def self.connect(path, *args)
       new(::UNIXSocket.new(path), *args)
     end
-    
+
     def initialize(socket)
       raise ArgumentError, "socket must be a UNIXSocket" unless socket.is_a? ::UNIXSocket
-      
+
       super
       @address_family, @path = socket.peeraddr
     end

data/lib/cool.io/timer_watcher.rb

@@ -10,7 +10,7 @@ module Coolio
     # Here we metaprogram proper event_callbacks for the callback methods
     # These can take a block and store it to be called when the event
     # is actually fired.
-    
+
     extend Meta
     event_callback :on_timer
   end

data/lib/cool.io/version.rb

@@ -0,0 +1,7 @@
+module Coolio
+  VERSION = "1.9.0"
+  
+  def self.version
+    VERSION
+  end
+end

data/lib/cool.io.rb

@@ -1,12 +1,13 @@
 #--
-# Copyright (C)2007-10 Tony Arcieri
+# Copyright (C)2011 Tony Arcieri
 # You can redistribute this under the terms of the Ruby license
 # See file LICENSE for details
 #++
 
-require 'iobuffer'
+require "cool.io/version"
+require "cool.io/custom_require"
+cool_require "cool.io_ext"
 
-require "cool.io_ext"
 require "cool.io/loop"
 require "cool.io/meta"
 require "cool.io/io"
@@ -17,16 +18,16 @@ require "cool.io/listener"
 require "cool.io/dns_resolver"
 require "cool.io/socket"
 require "cool.io/server"
-require "cool.io/http_client"
-require "cool.io/dsl"
 
 module Coolio
-  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
-  def self.version; VERSION; end
-  def self.inspect; "Cool.io"; end
+  def self.inspect
+    "Cool.io"
+  end
 end
 
 module Cool
   # Allow Coolio module to be referenced as Cool.io
-  def self.io; Coolio; end
-end
+  def self.io
+    Coolio
+  end
+end