cool.io 1.2.0-x86-mingw32

data/lib/cool.io/server.rb

@@ -0,0 +1,74 @@
+#--
+# 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 Server < Listener
+    # Servers listen for incoming connections and create new connection objects
+    # whenever incoming connections are received.  The default class for new
+    # connections is a Socket, but any subclass of IOWatcher is acceptable.
+    def initialize(listen_socket, klass = Socket, *args, &block)
+      # Ensure the provided class responds to attach
+      unless klass.allocate.is_a? IO
+        raise ArgumentError, "can't convert #{klass} to Coolio::IO"
+      end
+
+      # Verify the arity of the provided arguments
+      arity = klass.instance_method(:initialize).arity
+      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})"
+      end
+
+      @klass, @args, @block = klass, args, block
+      super(listen_socket)
+    end
+
+    # Returns an integer representing the underlying numeric file descriptor
+    def fileno
+      @listen_socket.fileno
+    end
+
+    #########
+    protected
+    #########
+
+    def on_connection(socket)
+      connection = @klass.new(socket, *@args).attach(evloop)
+      connection.__send__(:on_connect)
+      @block.call(connection) if @block
+    end
+  end
+
+  # TCP server class.  Listens on the specified host and port and creates
+  # new connection objects of the given class. This is the most common server class.
+  # Note that the new connection objects will be bound by default to the same event loop that the server is attached to.
+  # Optionally, it can also take any existing core TCPServer object as
+  # +host+ and create a Coolio::TCPServer out of it.
+  class TCPServer < Server
+    def initialize(host, port = nil, klass = TCPSocket, *args, &block)
+      listen_socket = if ::TCPServer === host
+        host
+      else
+        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
+      super(listen_socket, klass, *args, &block)
+    end
+  end
+
+  # UNIX server class.  Listens on the specified UNIX domain socket and
+  # creates new connection objects of the given class.
+  # Optionally, it can also take any existing core UNIXServer object as
+  # +path+ and create a Coolio::UNIXServer out of it.
+  class UNIXServer < Server
+    def initialize(path, klass = UNIXSocket, *args, &block)
+      s = ::UNIXServer === path ? path : ::UNIXServer.new(path)
+      super(s, klass, *args, &block)
+    end
+  end
+end

data/lib/cool.io/socket.rb

@@ -0,0 +1,230 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'socket'
+require 'resolv'
+
+module Coolio
+  class Socket < IO
+    def self.connect(socket, *args)
+
+      new(socket, *args).instance_eval do
+        @_connector = Connector.new(self, socket)
+        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
+
+    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
+
+        if connect_successful?
+          @coolio_socket.instance_eval { @_connector = nil }
+          @coolio_socket.attach(evl)
+          @ruby_socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, [1].pack("l"))
+          @ruby_socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+
+          @coolio_socket.__send__(:on_connect)
+        else
+          @coolio_socket.instance_eval { @_failed = true }
+          @coolio_socket.__send__(:on_connect_failed)
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def connect_successful?
+        @ruby_socket.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR).unpack('i').first == 0
+      rescue IOError
+        false
+      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
+    # the socket we want to use to create the watcher yet, since we don't
+    # know the IP address to connect to.
+    def self.precreate(*args, &block)
+      obj = allocate
+      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.
+    def self.connect(addr, port, *args)
+      family = nil
+
+      if (Resolv::IPv4.create(addr) rescue nil)
+        family = ::Socket::AF_INET
+      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
+
+      if host = Coolio::DNSResolver.hosts(addr)
+        return connect(host, port, *args) # calls this same function
+      end
+
+      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
+      @remote_host, @remote_addr, @remote_port = addr, addr, port
+      @_resolver = TCPConnectResolver.new(self, addr, port, *args)
+    end
+
+    private :preinitialize
+
+    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
+    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
+        @address_family = nil
+
+        super(family, ::Socket::SOCK_STREAM, 0)
+        begin
+          connect_nonblock(::Socket.sockaddr_in(port, addr))
+        rescue Errno::EINPROGRESS
+        end
+      end
+
+      def peeraddr
+        [
+          @address_family == ::Socket::AF_INET ? 'AF_INET' : 'AF_INET6',
+          @port,
+          @host,
+          @addr
+        ]
+      end
+    end
+
+    class TCPConnectResolver < Coolio::DNSResolver
+      def initialize(socket, host, port, *args)
+        @sock, @host, @port, @args = socket, host, port, args
+        super(host)
+      end
+
+      def on_success(addr)
+        host, port, args = @host, @port, @args
+
+        @sock.instance_eval do
+          # DNSResolver only supports IPv4 so we can safely assume IPv4 address
+          begin
+            socket = TCPConnectSocket.new(::Socket::AF_INET, addr, port, host)
+          rescue Errno::ENETUNREACH
+            on_connect_failed
+            return
+          end
+
+          initialize(socket, *args)
+          @_connector = Socket::Connector.new(self, socket)
+          @_resolver = nil
+        end
+        @sock.attach(evloop)
+      end
+
+      def on_failure
+        @sock.__send__(:on_resolve_failed)
+        @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
+  end
+end

data/lib/cool.io/timer_watcher.rb

@@ -0,0 +1,17 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  class TimerWatcher
+    # 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_timer
+  end
+end

data/lib/cool.io/version.rb

@@ -0,0 +1,5 @@
+module Coolio
+  VERSION = "1.2.0"
+  
+  def self.version; VERSION; end
+end

data/lib/coolio.rb

@@ -0,0 +1,2 @@
+# For those people who don't like the cool.io styling...
+require 'cool.io'

data/spec/async_watcher_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'tempfile'
+require 'fcntl'
+
+describe Cool.io::AsyncWatcher, :env => :win do
+
+  it "does not signal on spurious wakeups" do
+    aw = Cool.io::AsyncWatcher.new
+    tmp = Tempfile.new('coolio_async_watcher_test')
+    nr_fork = 2 # must be at least two for spurious wakeups
+
+    # We have aetter chance of failing if this overflows the pipe buffer
+    # which POSIX requires >= 512 bytes, Linux 2.6 uses 4096 bytes
+    nr_signal = 4096 * 4
+
+    append = File.open(tmp.path, "ab")
+    append.sync = true
+    rd, wr = ::IO.pipe
+
+    aw.on_signal { append.syswrite("#$$\n") }
+    children = nr_fork.times.map do
+      fork do
+        trap(:TERM) { exit!(0) }
+        rloop = Cool.io::Loop.default
+        aw.attach(rloop)
+        wr.write '.' # signal to master that we're ready
+        rloop.run
+        exit!(1) # should not get here
+      end
+    end
+
+    # ensure children are ready
+    nr_fork.times { rd.sysread(1).should == '.' }
+
+    # send our signals
+    nr_signal.times { aw.signal }
+
+    # wait for the pipe buffer to be consumed by the children
+    sleep 1 while tmp.stat.ctime >= (Time.now - 4)
+
+    children.each do |pid|
+      Process.kill(:TERM, pid)
+      _, status = Process.waitpid2(pid)
+      status.exitstatus.should == 0
+    end
+
+    # we should've written a line for every signal we sent
+    lines = tmp.readlines
+    lines.size.should == nr_signal
+
+    # theoretically a bad kernel scheduler could give us fewer...
+    lines.sort.uniq.size.should == nr_fork
+
+    tmp.close!
+  end
+
+end

data/spec/dns_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+VALID_DOMAIN = "google.com"
+INVALID_DOMAIN = "gibidigibigididibitidibigitibidigitidididi.com"
+
+class ItWorked < StandardError; end
+class WontResolve < StandardError; end
+
+class ConnectorThingy < Cool.io::TCPSocket
+  def on_connect
+    raise ItWorked
+  end
+
+  def on_resolve_failed
+    raise WontResolve
+  end
+end
+
+describe "DNS" do
+  before :each do
+    @loop = Cool.io::Loop.new
+  end
+  
+  it "connects to valid domains" do
+    ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
+    
+    proc do
+      @loop.run
+    end.should raise_error(ItWorked)
+  end
+  
+  it "fires on_resolve_failed for invalid domains" do
+    ConnectorThingy.connect(INVALID_DOMAIN, 80).attach(@loop)
+    
+    proc do
+      @loop.run
+    end.should raise_error(WontResolve)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'cool.io'
+
+RSpec.configure do |c|
+  if RUBY_PLATFORM =~ /mingw|win32/
+    $stderr.puts "Skip some specs on Windows"
+    c.filter_run_excluding :env => :win
+  end
+end

data/spec/stat_watcher_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+TEMP_FILE_PATH = "./test.txt"
+
+INTERVAL = 0.010
+
+class MyStatWatcher < Cool.io::StatWatcher
+  attr_accessor :accessed, :previous, :current
+
+  def initialize(path)
+    super path, INTERVAL
+  end
+
+  def on_change(previous, current)
+    self.accessed = true
+    self.previous = previous
+    self.current  = current
+  end
+end
+
+def run_with_file_change(path)
+  reactor = Cool.io::Loop.new
+
+  sw = MyStatWatcher.new(path)
+  sw.attach(reactor)
+
+  tw = Cool.io::TimerWatcher.new(INTERVAL, true)
+  tw.on_timer do
+    reactor.stop if sw.accessed
+    write_file(path)
+  end
+  tw.attach(reactor)
+
+  reactor.run
+
+  tw.detach
+  sw.detach
+
+  sw
+end
+
+def write_file(path)
+  File.open(path, "w+") { |f| f.write(rand.to_s) }
+end
+
+def delete_file(path)
+  File.delete(TEMP_FILE_PATH)
+end
+
+describe Cool.io::StatWatcher do
+
+  let :watcher do
+    run_with_file_change(TEMP_FILE_PATH)
+  end
+
+  before :each do
+    write_file(TEMP_FILE_PATH)
+  end
+
+  after :each do
+    delete_file(TEMP_FILE_PATH)
+  end
+
+  it "fire on_change when the file it is watching is modified" do
+    watcher.accessed.should eql(true)
+  end
+
+  it "should pass previous and current file stat info given a stat watcher" do
+    watcher.previous.ino.should eql(watcher.current.ino)
+  end
+
+  it "should raise when the handler does not take 2 parameters" do
+    class MyStatWatcher < Cool.io::StatWatcher; def on_change; end; end
+    lambda { watcher.accessed }.should raise_error(ArgumentError)
+  end
+
+end