cool.io 1.4.1-x64-mingw32

data/lib/cool.io/dsl.rb

@@ -0,0 +1,139 @@
+#--
+# Copyright (C)2010 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  # A module we stash all the connections defined by the DSL under
+  module Connections; end
+
+  # A DSL for defining Cool.io connection types and servers
+  module DSL
+    # Define all methods on the metaclass
+    module_function
+
+    # Run the default Cool.io event loop
+    def run
+      Cool.io::Loop.default.run
+    end
+
+    # Connect to the given host and port using the given connection class
+    def connect(host, port, connection_name = nil, *initializer_args, &block)
+      if block_given?
+        initializer_args.unshift connection_name if connection_name
+
+        klass = Class.new Cool.io::TCPSocket
+        connection_builder = ConnectionBuilder.new klass
+        connection_builder.instance_eval(&block)
+      else
+        raise ArgumentError, "no connection name or block given" unless connection_name
+        klass = self[connection_name]
+      end
+
+      client = klass.connect host, port, *initializer_args
+      client.attach Cool.io::Loop.default
+      client
+    end
+
+    # Create a new Cool.io::TCPServer
+    def server(host, port, connection_name = nil, *initializer_args, &block)
+      if block_given?
+        initializer_args.unshift connection_name if connection_name
+
+        klass = Class.new Cool.io::TCPSocket
+        connection_builder = ConnectionBuilder.new klass
+        connection_builder.instance_eval(&block)
+      else
+        raise ArgumentError, "no connection name or block given" unless connection_name
+        klass = self[connection_name]
+      end
+
+      server = Cool.io::TCPServer.new host, port, klass, *initializer_args
+      server.attach Cool.io::Loop.default
+      server
+    end
+
+    # Create a new Cool.io::TCPSocket class
+    def connection(name, &block)
+      # Camelize class name
+      class_name = name.to_s.split('_').map { |s| s.capitalize }.join
+
+      connection = Class.new Cool.io::TCPSocket
+      connection_builder = ConnectionBuilder.new connection
+      connection_builder.instance_eval(&block)
+
+      Coolio::Connections.const_set class_name, connection
+    end
+
+    # Look up a connection class by its name
+    def [](connection_name)
+      class_name = connection_name.to_s.split('_').map { |s| s.capitalize }.join
+
+      begin
+        Coolio::Connections.const_get class_name
+      rescue NameError
+        raise NameError, "No connection type registered for #{connection_name.inspect}"
+      end
+    end
+
+    # Builder for Cool.io::TCPSocket classes
+    class ConnectionBuilder
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # Declare an initialize function
+      def initializer(&action)
+        @klass.send :define_method, :initialize, &action
+      end
+
+      # Declare the on_connect callback
+      def on_connect(&action)
+        @klass.send :define_method, :on_connect, &action
+      end
+
+      # Declare a callback fired if we failed to connect
+      def on_connect_failed(&action)
+        @klass.send :define_method, :on_connect_failed, &action
+      end
+
+      # Declare a callback fired if DNS resolution failed
+      def on_resolve_failed(&action)
+        @klass.send :define_method, :on_resolve_failed, &action
+      end
+
+      # Declare the on_close callback
+      def on_close(&action)
+        @klass.send :define_method, :on_close, &action
+      end
+
+      # Declare the on_read callback
+      def on_read(&action)
+        @klass.send :define_method, :on_read, &action
+      end
+
+      # Declare the on_write_complete callback
+      def on_write_complete(&action)
+        @klass.send :define_method, :on_write_complete, &action
+      end
+    end
+  end
+end
+
+# The Cool module containing all our coolness
+module Cool
+  module Coolness
+    def cool
+      Cool::IOThunk
+    end
+  end
+
+  module IOThunk
+    def self.io
+      Coolio::DSL
+    end
+  end
+end
+
+extend Cool::Coolness

data/lib/cool.io/io.rb

@@ -0,0 +1,194 @@
+#--
+# 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
+      # TODO should these detect write buffers, as well?
+      @_read_watcher.detach
+      self
+    end
+
+    # 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
+
+    # Close the IO stream
+    def close
+      detach if attached?
+      detach_write_watcher
+      @_io.close unless 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 @_read_watcher.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,99 @@
+#--
+# 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
+
+    def listen(backlog)
+      @listen_socket.listen(backlog)
+    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
+
+  DEFAULT_BACKLOG = 1024
+
+  class TCPListener < Listener
+    # 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)
+      s = ::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
+      super(s)
+    end
+  end
+end