cool.io 0.9.0

data/ext/libev/test_libev_win32.c

@@ -0,0 +1,123 @@
+  // a single header file is required
+  #include <ev.h>
+   #include <stdio.h>
+   #include <io.h>
+   
+   // every watcher type has its own typedef'd struct
+   // with the name ev_TYPE
+   ev_io stdin_watcher;
+   ev_timer timeout_watcher;
+
+   // all watcher callbacks have a similar signature
+   // this callback is called when data is readable on stdin
+   static void
+   stdin_cb (EV_P_ ev_io *w, int revents)
+   {
+     puts ("stdin ready or done or something");
+     // for one-shot events, one must manually stop the watcher
+     // with its corresponding stop function.
+     //ev_io_stop (EV_A_ w);
+
+     // this causes all nested ev_loop's to stop iterating
+     //ev_unloop (EV_A_ EVUNLOOP_ALL);
+   }
+
+   // another callback, this time for a time-out
+   static void
+   timeout_cb (EV_P_ ev_timer *w, int revents)
+   {
+     puts ("timeout");
+     // this causes the innermost ev_loop to stop iterating
+     ev_unloop (EV_A_ EVUNLOOP_ONE);
+   }
+
+   
+   
+   #include <winsock.h>
+
+#include <stdlib.h>
+#include <iostream>
+   int get_server_fd()
+   {
+ 
+  //----------------------
+  // Initialize Winsock.
+  WSADATA wsaData;
+  int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+  if (iResult != NO_ERROR) {
+    printf("Error at WSAStartup()\n");
+    return 1;
+  }
+
+  //----------------------
+  // Create a SOCKET for listening for
+  // incoming connection requests.
+  SOCKET ListenSocket;
+  ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (ListenSocket == INVALID_SOCKET) {
+    printf("Error at socket(): %ld\n", WSAGetLastError());
+    WSACleanup();
+    return 1;
+  }
+  printf("socket returned %d\n", ListenSocket);
+ 
+  //----------------------
+  // The sockaddr_in structure specifies the address family,
+  // IP address, and port for the socket that is being bound.
+  sockaddr_in service;
+  service.sin_family = AF_INET;
+  service.sin_addr.s_addr = inet_addr("127.0.0.1");
+  service.sin_port = htons(4444);
+
+  if (bind( ListenSocket, 
+    (SOCKADDR*) &service, 
+    sizeof(service)) == SOCKET_ERROR) {
+    printf("bind() failed.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+  //----------------------
+  // Listen for incoming connection requests.
+  // on the created socket
+  if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
+    printf("Error listening on socket.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+  
+  printf("sock and osf handle are %d %d, error is \n", ListenSocket, _get_osfhandle (ListenSocket)); // -1 is invalid file handle: http://msdn.microsoft.com/en-us/library/ks2530z6.aspx
+  printf("err was %d\n",  WSAGetLastError());
+  //----------------------
+  return ListenSocket;
+   }
+   
+   
+   int
+   main (void)
+   {
+     struct ev_loop *loopy = ev_default_loop(0);
+     int fd = get_server_fd();
+     int fd_real =  _open_osfhandle(fd, NULL);
+     int conv = _get_osfhandle(fd_real);
+     printf("got server fd %d, loop %d, fd_real %d, that converted %d\n", fd, loopy, fd_real, conv); 
+    // accept(fd, NULL, NULL);
+     // initialise an io watcher, then start it
+     // this one will watch for stdin to become readable
+     ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ conv, EV_READ);
+     ev_io_start (loopy, &stdin_watcher);
+
+     // initialise a timer watcher, then start it
+     // simple non-repeating 5.5 second timeout
+     //ev_timer_init (&timeout_watcher, timeout_cb, 15.5, 0.);
+     //ev_timer_start (loopy, &timeout_watcher);
+    printf("starting loop\n");
+     // now wait for events to arrive
+     ev_loop (loopy, 0);
+
+     // unloop was called, so exit
+     return 0;
+   }

data/ext/libev/update_ev_wrap

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+(
+   echo '#define VAR(name,decl) name'
+   echo '#define EV_GENWRAP 1'
+   cat ev_vars.h
+) | cc -E -o - - | perl -ne '
+   while (<>) {
+      push @syms, $1 if /(^\w+)/;
+   }
+   print "/* DO NOT EDIT, automatically generated by update_ev_wrap */\n",
+         "#ifndef EV_WRAP_H\n",
+         "#define EV_WRAP_H\n",
+         (map "#define $_ ((loop)->$_)\n", @syms),
+         "#else\n",
+         "#undef EV_WRAP_H\n",
+         (map "#undef $_\n", @syms),
+         "#endif\n";
+' >ev_wrap.h

data/lib/.gitignore

@@ -0,0 +1,2 @@
+*.so
+*.bundle

data/lib/cool.io.rb

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

data/lib/cool.io/async_watcher.rb

@@ -0,0 +1,43 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Coolio
+  # The AsyncWatcher lets you signal another thread to wake up.  Its
+  # intended use is notifying another thread of events.
+  class AsyncWatcher < IOWatcher
+    def initialize
+      @reader, @writer = ::IO.pipe
+      super(@reader)
+    end
+
+    # Signal the async watcher.  This call is thread safe.
+    def signal
+      # Write a byte to the pipe.  What we write is meaningless, it
+      # merely signals an event has occurred for each byte written.
+      @writer.write "\0"
+    end
+    
+    # Called whenever a signal is received
+    def on_signal; end
+    event_callback :on_signal
+
+    #########
+    protected
+    #########
+
+    def on_readable
+      # Read a byte from the pipe.  This clears readability, unless
+      # another signal is pending
+      begin
+        @reader.read_nonblock 1
+      rescue Errno::EAGAIN
+        # in case there are spurious wakeups from forked processs
+        return
+      end
+      on_signal
+    end
+  end
+end

data/lib/cool.io/dns_resolver.rb

@@ -0,0 +1,220 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#
+# Gimpy hacka asynchronous DNS resolver
+#
+# Word to the wise: I don't know what I'm doing here.  This was cobbled together
+# as best I could with extremely limited knowledge of the DNS format.  There's
+# obviously a ton of stuff it doesn't support (like IPv6 and TCP).
+#
+# If you do know what you're doing with DNS, feel free to improve this! 
+# A good starting point my be this EventMachine Net::DNS-based asynchronous
+# resolver:
+#
+# http://gist.github.com/663299
+#
+#++
+
+module Coolio
+  # A non-blocking DNS resolver.  It provides interfaces for querying both
+  # /etc/hosts and nameserves listed in /etc/resolv.conf, or nameservers of
+  # your choosing.
+  #
+  # Presently the client only supports UDP requests against your nameservers
+  # and cannot resolve anything with records larger than 512-bytes.  Also,
+  # IPv6 is not presently supported.
+  #
+  # DNSResolver objects are one-shot.  Once they resolve a domain name they
+  # automatically detach themselves from the event loop and cannot be used
+  # again.
+  class DNSResolver < IOWatcher
+    #--
+    # TODO check if it's caching right
+    RESOLV_CONF = '/etc/resolv.conf'
+    HOSTS = '/etc/hosts'
+    DNS_PORT = 53
+    DATAGRAM_SIZE = 512
+    TIMEOUT = 3 # Retry timeout for each datagram sent
+    RETRIES = 4 # Number of retries to attempt
+    # so currently total is 12s before it will err due to timeouts
+    # if it errs due to inability to reach the DNS server [Errno::EHOSTUNREACH], same
+
+    # Query /etc/hosts (or the specified hostfile) for the given host
+    def self.hosts(host, hostfile = HOSTS)
+      hosts = {}
+      File.open(hostfile).each_line do |host_entry|
+        entries = host_entry.gsub(/#.*$/, '').gsub(/\s+/, ' ').split(' ')
+        addr = entries.shift
+        entries.each { |e| hosts[e] ||= addr }
+      end
+
+      hosts[host]
+    end
+
+    # Create a new Coolio::Watcher descended object to resolve the
+    # given hostname.  If you so desire you can also specify a
+    # list of nameservers to query.  By default the resolver will
+    # use nameservers listed in /etc/resolv.conf
+    def initialize(hostname, *nameservers)
+      if nameservers.empty?
+        nameservers = File.read(RESOLV_CONF).scan(/^\s*nameserver\s+([0-9.:]+)/).flatten # TODO could optimize this to just read once
+        raise RuntimeError, "no nameservers found in #{RESOLV_CONF}" if nameservers.empty? # TODO just call resolve_failed, not raise [also handle Errno::ENOENT)]
+      end
+
+      @nameservers = nameservers
+      @question = request_question hostname
+      
+      @socket = UDPSocket.new
+      @timer = Timeout.new(self)
+      
+      super(@socket)
+    end
+
+    # Attach the DNSResolver to the given event loop
+    def attach(evloop)
+      send_request
+      @timer.attach(evloop)
+      super
+    end
+
+    # Detach the DNSResolver from the given event loop
+    def detach
+      @timer.detach if @timer.attached?
+      super
+    end
+
+    # Called when the name has successfully resolved to an address
+    def on_success(address); end
+    event_callback :on_success
+
+    # Called when we receive a response indicating the name didn't resolve
+    def on_failure; end
+    event_callback :on_failure
+
+    # Called if we don't receive a response, defaults to calling on_failure
+    def on_timeout
+      on_failure
+    end
+
+    #########
+    protected
+    #########
+
+    # Send a request to the DNS server
+    def send_request
+      nameserver = @nameservers.shift
+      @nameservers << nameserver # rotate them
+      @socket.connect @nameservers.first, DNS_PORT
+      begin
+        @socket.send request_message, 0
+      rescue Errno::EHOSTUNREACH # TODO figure out why it has to be wrapper here, when the other wrapper should be wrapping this one!
+      end   
+    end
+
+    # Called by the subclass when the DNS response is available
+    def on_readable
+      datagram = nil
+      begin
+        datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
+      rescue Errno::ECONNREFUSED
+      end
+      
+      address = response_address datagram rescue nil
+      address ? on_success(address) : on_failure
+      detach
+    end
+
+    def request_question(hostname)
+      raise ArgumentError, "hostname cannot be nil" if hostname.nil?
+      
+      # Query name
+      message = hostname.split('.').map { |s| [s.size].pack('C') << s }.join + "\0"
+
+      # Host address query
+      qtype = 1
+
+      # Internet query
+      qclass = 1
+
+      message << [qtype, qclass].pack('nn')
+    end
+
+    def request_message
+      # Standard query header
+      message = [2, 1, 0].pack('nCC')
+
+      # One entry
+      qdcount = 1
+
+      # No answer, authority, or additional records
+      ancount = nscount = arcount = 0 
+
+      message << [qdcount, ancount, nscount, arcount].pack('nnnn')
+      message << @question
+    end
+
+    def response_address(message)
+      # Confirm the ID field
+      id = message[0..1].unpack('n').first.to_i
+      return unless id == 2
+
+      # Check the QR value and confirm this message is a response
+      qr = message[2..2].unpack('B1').first.to_i
+      return unless qr == 1
+
+      # Check the RCODE (lower nibble) and ensure there wasn't an error
+      rcode = message[3..3].unpack('B8').first[4..7].to_i(2)
+      return unless rcode == 0
+
+      # Extract the question and answer counts
+      qdcount, ancount = message[4..7].unpack('nn').map { |n| n.to_i }
+
+      # We only asked one question
+      return unless qdcount == 1
+      message.slice!(0, 12)
+
+      # Make sure it's the same question
+      return unless message[0..(@question.size-1)] == @question
+      message.slice!(0, @question.size)
+
+      # Extract the RDLENGTH
+      while not message.empty?
+        type = message[2..3].unpack('n').first.to_i
+        rdlength = message[10..11].unpack('n').first.to_i
+        rdata = message[12..(12 + rdlength - 1)]
+        message.slice!(0, 12 + rdlength)
+
+        # Only IPv4 supported
+        next unless rdlength == 4
+
+        # If we got an Internet address back, return it
+        return rdata.unpack('CCCC').join('.') if type == 1
+      end
+
+      nil
+    end
+
+    class Timeout < TimerWatcher
+      def initialize(resolver)
+        @resolver = resolver
+        @attempts = 0
+        super(TIMEOUT, true)
+      end
+
+      def on_timer
+        @attempts += 1
+        if @attempts <= RETRIES
+          begin
+            return @resolver.__send__(:send_request)
+          rescue Errno::EHOSTUNREACH # if the DNS is toast try again after the timeout occurs again
+            return nil
+          end 
+        end
+        @resolver.__send__(:on_timeout)
+        @resolver.detach
+      end
+    end
+  end
+end

data/lib/cool.io/eventmachine.rb

@@ -0,0 +1,234 @@
+#--
+# Copyright (C)2007-10 Tony Arcieri, Roger Pack
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'cool.io'
+
+# EventMachine emulation for Cool.io:
+#
+#   require 'coolio/eventmachine'
+#
+# Drawbacks: slightly slower than EM.
+# Benefits: timers are more accurate using libev than using EM
+# TODO: some things like connection timeouts aren't implemented yet
+# DONE: timers and normal socket functions are implemented.
+module EventMachine
+  class << self
+    # Start the Reactor loop
+    def run
+      yield if block_given?
+      Coolio::Loop.default.run
+    end
+
+    # Stop the Reactor loop
+    def stop_event_loop
+      Coolio::Loop.default.stop
+    end
+
+    class OneShotEMTimer < Coolio::TimerWatcher
+      def setup(proc)
+        @proc = proc
+      end
+
+      def on_timer
+       @proc.call
+      end
+    end
+
+    # ltodo: use Coolio's PeriodicTimer to wrap EM's two similar to it
+    # todo: close all connections on 'stop', I believe
+
+    def add_timer(interval, proc = nil, &block)
+      block ||= proc
+      t = OneShotEMTimer.new(interval, false) # non repeating
+      t.setup(block) 
+      
+      # fire 'er off ltodo: do we keep track of these timers in memory?
+      t.attach(Coolio::Loop.default)
+      t
+    end
+
+    def cancel_timer(t)
+      # guess there's a case where EM you can say 'cancel' but it's already fired?
+      # kind of odd but it happens
+     t.detach if t.attached? 
+    end
+
+    def set_comm_inactivity_timeout(*args); end # TODO
+
+    # Make an outgoing connection
+    def connect(addr, port, handler = Connection, *args, &block)
+      block = args.pop if Proc === args[-1]
+
+      # make sure we're a 'real' class here
+      klass = if (handler and handler.is_a?(Class))
+        handler
+      else
+        Class.new( Connection ) {handler and include handler}
+      end
+
+      wrapped_child = CallsBackToEM.connect(addr, port, *args) # ltodo: args? what? they're used? also TODOC TODO FIX
+      conn = klass.new(wrapped_child) # ltodo [?] addr, port, *args)
+      wrapped_child.attach(Coolio::Loop.default) # necessary
+      conn.heres_your_socket(wrapped_child)
+      wrapped_child.call_back_to_this(conn) # calls post_init for us
+      yield conn if block_given?
+    end
+    
+    # Start a TCP server on the given address and port
+    def start_server(addr, port, handler = Connection, *args, &block)
+      # make sure we're a 'real' class here
+      klass = if (handler and handler.is_a?(Class))
+        handler
+      else
+        Class.new( Connection ) {handler and include handler}
+      end
+      
+      server = Coolio::TCPServer.new(addr, port, CallsBackToEM, *args) do |wrapped_child| 
+        conn = klass.new(wrapped_child)
+        conn.heres_your_socket(wrapped_child) # ideally NOT have this :)
+        wrapped_child.call_back_to_this(conn) 
+        block.call(conn) if block
+      end
+
+      server.attach(Coolio::Loop.default)
+    end
+
+    def stop_server(server)
+      server.close
+    end
+
+    # Set the maximum number of descriptors available to this process
+    def set_descriptor_table_size(nfds)
+      Coolio::Utils.maxfds = nfds
+    end
+
+    # Compatibility noop.  Handled automatically by libev
+    def epoll; end
+
+    # Compatibility noop.  Handled automatically by libev
+    def kqueue; end
+  end
+
+  class CallsBackToEM < Coolio::TCPSocket
+    class ConnectTimer < Coolio::TimerWatcher
+      attr_accessor :parent
+      def on_timer
+       @parent.connection_has_timed_out
+      end
+    end
+
+    def call_back_to_this parent
+      @call_back_to_this = parent
+      parent.post_init
+    end
+
+    def on_connect
+      # @connection_timer.detach if @connection_timer 
+      # won't need that anymore :) -- with server connecteds we don't have it, anyway
+      
+      # TODO should server accepted's call this? They don't currently
+      # [and can't, since on_connect gets called basically in the initializer--needs some code love for that to happen :)
+      @call_back_to_this.connection_completed if @call_back_to_this
+    end
+
+    def connection_has_timed_out
+      return if closed?
+      
+      # wonder if this works when you're within a half-connected phase.
+      # I think it does.  What about TCP state?
+      close unless closed? 
+      @call_back_to_this.unbind
+    end
+
+    def on_write_complete
+      close if @should_close_after_writing
+    end
+
+    def should_close_after_writing
+      @should_close_after_writing = true;
+    end
+
+    def on_close
+      @call_back_to_this.unbind # about the same ltodo check if they ARE the same here
+    end
+
+    def on_resolve_failed
+      fail
+    end
+
+    def on_connect_failed
+      fail
+    end
+
+    def on_read(data)
+      @call_back_to_this.receive_data data
+    end
+
+    def fail
+      #@connection_timer.detch if @connection_timer
+      @call_back_to_this.unbind
+    end
+
+    def self.connect(*args)
+      a = super *args
+      # the connect timer currently kills TCPServer classes.  I'm not sure why.
+      #@connection_timer = ConnectTimer.new(14) # needs to be at least higher than 12 :)
+      #@connection_timer.parent = a
+      #@connection_timer.attach(Coolio::Loop.default)
+      a
+    end
+  end
+
+  class Connection
+    def self.new(*args)
+      allocate#.instance_eval do
+      #  initialize *args
+      #end
+    end
+    
+    # we will need to call 'their functions' appropriately -- the commented out ones, here
+    # 
+    # Callback fired when connection is created
+    def post_init
+      # I thought we were 'overriding' EM's existing methods, here.  
+      # Huh? Why do we have to define these then?
+    end
+
+    # Callback fired when connection is closed
+    def unbind; end
+    
+    # Callback fired when data is received
+    # def receive_data(data); end
+    def heres_your_socket(instantiated_coolio_socket)
+      instantiated_coolio_socket.call_back_to_this self
+      @wrapped_coolio = instantiated_coolio_socket
+    end
+
+    # Send data to the current connection -- called by them
+    def send_data(data)
+      @wrapped_coolio.write data
+    end
+    
+    # Close the connection, optionally after writing
+    def close_connection(after_writing = false)
+      return close_connection_after_writing if after_writing
+      @wrapped_coolio.close
+    end
+    
+    # Close the connection after all data has been written
+    def close_connection_after_writing
+      @wrapped_coolio.output_buffer_size.zero? ? @wrapped_coolio.close : @wrapped_coolio.should_close_after_writing
+    end
+
+    def get_peername
+      family, port, host_name, host_ip = @wrapped_coolio.peeraddr
+      Socket.pack_sockaddr_in(port, host_ip) # pack it up :)
+    end
+  end
+end
+
+# Shortcut constant
+EM = EventMachine