cool.io 1.2.0-x86-mswin32-60

data/lib/cool.io/io.rb

@@ -0,0 +1,174 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  # A buffered I/O class witch fits into the Coolio Watcher framework.
+  # It provides both an observer which reads data as it's received
+  # from the wire and a buffered write watcher which stores data and writes
+  # it out each time the socket becomes writable.
+  #
+  # This class is primarily meant as a base class for other streams
+  # which need non-blocking writing, and is used to implement Coolio's
+  # 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
+      @_read_watcher  = Watcher.new(io, self, :r)
+      @_write_watcher = Watcher.new(io, self, :w)
+    end
+
+    #
+    # 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
+
+    # Detach from the event loop
+    def detach; @_read_watcher.detach; self; end # TODO should these detect write buffers, as well?
+
+    # Enable the watcher
+    def enable; @_read_watcher.enable; self; end
+
+    # Disable the watcher
+    def disable; @_read_watcher.disable; self; end
+
+    # Is the watcher attached?
+    def attached?; @_read_watcher.attached?; end
+
+    # Is the watcher enabled?
+    def enabled?; @_read_watcher.enabled?; end
+
+    # Obtain the event loop associated with this object
+    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
+
+    # Called whenever a write completes and the output buffer is empty
+    def on_write_complete; end
+    event_callback :on_write_complete
+
+    # Called whenever the IO object hits EOF
+    def on_close; end
+    event_callback :on_close
+
+    #
+    # Write interface
+    #
+
+    # Write data in a buffered, non-blocking manner
+    def write(data)
+      @_write_buffer << data
+      schedule_write
+      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?
+
+      on_close
+      nil
+    end
+
+    # Is the IO object closed?
+    def closed?
+      @_io.nil? or @_io.closed?
+    end
+
+    #########
+    protected
+    #########
+
+    # Read from the input buffer and dispatch to on_read
+    def on_readable
+      begin
+        on_read @_io.read_nonblock(INPUT_SIZE)
+      rescue Errno::EAGAIN, Errno::EINTR
+        return
+
+      # SystemCallError catches Errno::ECONNRESET amongst others.
+      rescue SystemCallError, EOFError, IOError, SocketError
+        close
+      end
+    end
+
+    # Write the contents of the output buffer
+    def on_writable
+      begin
+        @_write_buffer.write_to(@_io)
+      rescue Errno::EINTR
+        return
+
+      # SystemCallError catches Errno::EPIPE & Errno::ECONNRESET amongst others.
+      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
+    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
+      begin
+        enable_write_watcher
+      rescue IOError
+      end
+    end
+
+    def enable_write_watcher
+      if @_write_watcher.attached?
+        @_write_watcher.enable unless @_write_watcher.enabled?
+      else
+        @_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)
+        @coolio_io = coolio_io
+        super(ruby_io, flags)
+      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
+    end
+  end
+end

data/lib/cool.io/iowatcher.rb

@@ -0,0 +1,17 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  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
+    # is actually fired.
+
+    extend Meta
+    event_callback :on_readable, :on_writable
+  end
+end

data/lib/cool.io/listener.rb

@@ -0,0 +1,93 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'socket'
+
+module Coolio
+  # Listeners wait for incoming connections.  When a listener receives a
+  # connection it fires the on_connection event with the newly accepted
+  # socket as a parameter.
+  class Listener < IOWatcher
+    def initialize(listen_socket)
+      @listen_socket = listen_socket
+      super(@listen_socket)
+    end
+
+    # Returns an integer representing the underlying numeric file descriptor
+    def fileno
+      @listen_socket.fileno
+    end
+
+    # Close the listener
+    def close
+      detach if attached?
+      @listen_socket.close
+    end
+
+    # Called whenever the server receives a new connection
+    def on_connection(socket); end
+    event_callback :on_connection
+
+    #########
+    protected
+    #########
+
+    # 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.
+      end
+    end
+  end
+
+  class TCPListener < Listener
+    DEFAULT_BACKLOG = 1024
+
+    # Create a new Coolio::TCPListener on the specified address and port.
+    # Accepts the following options:
+    #
+    #  :backlog - Max size of the pending connection queue (default 1024)
+    #  :reverse_lookup - Retain BasicSocket's reverse DNS functionality (default false)
+    #
+    # If the specified address is an TCPServer object, it will ignore
+    # the port and :backlog option and create a new Coolio::TCPListener out
+    # of the existing TCPServer object.
+    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
+        raise ArgumentError, "port must be an integer" if nil == port
+        ::TCPServer.new(addr, port)
+      end
+      listen_socket.instance_eval { listen(options[:backlog]) }
+      super(listen_socket)
+    end
+  end
+
+  class UNIXListener < Listener
+    # Create a new Coolio::UNIXListener
+    #
+    # Accepts the same arguments as UNIXServer.new
+    # 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))
+    end
+  end
+end

data/lib/cool.io/loop.rb

@@ -0,0 +1,130 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'thread'
+
+# Monkeypatch Thread to include a method for obtaining the default Coolio::Loop
+class Thread
+  def _coolio_loop
+    @_coolio_loop ||= Coolio::Loop.new
+  end
+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
+    end
+
+    # Create a new Coolio::Loop
+    #
+    # Options:
+    #
+    # :skip_environment (boolean)
+    #   Ignore the $LIBEV_FLAGS environment variable
+    #
+    # :fork_check (boolean)
+    #   Enable autodetection of forks
+    #
+    # :backend
+    #   Choose the default backend, one (or many in an array) of:
+    #     :select (most platforms)
+    #     :poll   (most platforms except Windows)
+    #     :epoll  (Linux)
+    #     :kqueue (BSD/Mac OS X)
+    #     :port   (Solaris 10)
+    #
+    def initialize(options = {})
+      @watchers = {}
+      @active_watchers = 0
+
+      flags = 0
+
+      options.each do |option, value|
+        case option
+        when :skip_environment
+          flags |= EVFLAG_NOEV if value
+        when :fork_check
+          flags |= EVFLAG_FORKCHECK if value
+        when :backend
+          value = [value] unless value.is_a? Array
+          value.each do |backend|
+            case backend
+            when :select then flags |= EVBACKEND_SELECT
+            when :poll   then flags |= EVBACKEND_POLL
+            when :epoll  then flags |= EVBACKEND_EPOLL
+            when :kqueue then flags |= EVBACKEND_KQUEUE
+            when :port   then flags |= EVBACKEND_PORT
+            else raise ArgumentError, "no such backend: #{backend}"
+            end
+          end
+        else raise ArgumentError, "no such option: #{option}"
+        end
+      end
+
+      @loop = ev_loop_new(flags)
+    end
+
+    # Attach a watcher to the loop
+    def attach(watcher)
+      watcher.attach self
+    end
+
+    # Run the event loop and dispatch events back to Ruby.  If there
+    # 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
+    # explicitly stopped by calling the stop method on the loop object.
+    def run
+      raise RuntimeError, "no watchers for this loop" if @watchers.empty?
+
+      @running = true
+      while @running and not @active_watchers.zero?
+        run_once
+      end
+      @running = false
+    end
+
+    # Stop the event loop if it's running
+    def stop
+      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_PORT   = 0x00000020 # solaris 10
+  end
+end

data/lib/cool.io/meta.rb

@@ -0,0 +1,49 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  module Meta
+    # Use an alternate watcher with the attach/detach/enable/disable methods
+    # if it is presently assigned.  This is useful if you are waiting for
+    # 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|
+        module_eval <<-EOD
+          def #{method}(*args)
+            if defined? #{proxy_var} and #{proxy_var}
+              #{proxy_var}.#{method}(*args)
+              return self
+            end
+
+            super
+          end
+        EOD
+      end
+    end
+
+    # Define callbacks whose behavior can be changed on-the-fly per instance.
+    # This is done by giving a block to the callback method, which is captured
+    # as a proc and stored for later.  If the method is called without a block,
+    # the stored block is executed if present, otherwise it's a noop.
+    def event_callback(*methods)
+      methods.each do |method|
+        module_eval <<-EOD
+          def #{method}(*args, &block)
+            if block
+              @#{method}_callback = block
+              return
+            end
+
+            if defined? @#{method}_callback and @#{method}_callback
+              instance_exec(*args, &@#{method}_callback)
+            end
+          end
+        EOD
+      end
+    end
+  end
+end