cool.io 1.4.1-x64-mingw32

data/ext/libev/ruby_gil.patch

@@ -0,0 +1,97 @@
+diff --git a/ext/libev/ev.c b/ext/libev/ev.c
+index e5bd5ab..10f6ff2 100644
+--- a/ext/libev/ev.c
++++ b/ext/libev/ev.c
+@@ -37,6 +37,10 @@
+  * either the BSD or the GPL.
+  */
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#include "ruby.h"
++/* ######################################## */
++
+ /* this big block deduces configuration from config.h */
+ #ifndef EV_STANDALONE
+ # ifdef EV_CONFIG_H
+@@ -3237,9 +3241,27 @@ time_update (EV_P_ ev_tstamp max_block)
+     }
+ }
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++static
++VALUE ev_backend_poll(void **args)
++{
++  struct ev_loop *loop = (struct ev_loop *)args[0];
++  ev_tstamp waittime = *(ev_tstamp *)args[1];
++  backend_poll (EV_A_ waittime);
++}
++#endif
++/* ######################################## */
++
+ int
+ ev_run (EV_P_ int flags)
+ {
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++    void *poll_args[2];
++#endif
++/* ######################################## */
++
+ #if EV_FEATURE_API
+   ++loop_depth;
+ #endif
+@@ -3357,7 +3379,53 @@ ev_run (EV_P_ int flags)
+         ++loop_count;
+ #endif
+         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
++
++/*
++########################## COOLIO PATCHERY HO! ##########################
++
++The original patch file is made by Tony Arcieri.
++https://github.com/celluloid/nio4r/blob/680143345726c5a64bb22376ca8fc3c6857019ae/ext/libev/ruby_gil.patch.
++
++According to the grandwizards of Ruby, locking and unlocking of the global
++interpreter lock are apparently too powerful a concept for a mere mortal to
++wield (although redefining what + and - do to numbers is totally cool).
++And so it came to pass that the only acceptable way to release the global
++interpreter lock is through a convoluted callback system that thakes a
++function pointer. While the grandwizard of libev foresaw this sort of scenario,
++he too attempted to place an API with callbacks on it, one that runs before
++the system call, and one that runs immediately after.
++
++And so it came to pass that trying to wrap everything up in callbacks created
++two incompatible APIs, Ruby's which releases the global interpreter lock and
++reacquires it when the callback returns, and libev's, which wants two
++callbacks, one which runs before the polling operation starts, and one which
++runs after it finishes.
++
++These two systems are incompatible as they both want to use callbacks to
++solve the same problem, however libev wants to use before/after callbacks,
++and Ruby wants to use an "around" callback. This presents a significant
++problem as these two patterns of callbacks are diametrical opposites of each
++other and thus cannot be composed.
++
++And thus we are left with no choice but to patch the internals of libev in
++order to release a mutex at just the precise moment.
++
++Let this be a lesson to the all: CALLBACKS FUCKING BLOW
++
++#######################################################################
++*/
++
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++        poll_args[0] = (void *)loop;
++        poll_args[1] = (void *)&waittime;
++        rb_thread_blocking_region(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
++#else
+         backend_poll (EV_A_ waittime);
++#endif
++/*
++############################# END PATCHERY ############################
++*/
++
+         assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
+ 
+         pipe_write_wanted = 0; /* just an optimisation, no fence needed */

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/win_select.patch

@@ -0,0 +1,115 @@
+diff --git a/ext/libev/ev_select.c b/ext/libev/ev_select.c
+index f38d6ca..3a32642 100644
+--- a/ext/libev/ev_select.c
++++ b/ext/libev/ev_select.c
+@@ -67,6 +67,53 @@
+ 
+ #include <string.h>
+ 
++#ifdef _WIN32
++/*
++########## COOLIO PATCHERY HO! ##########
++
++Ruby undefs FD_* utilities for own implementation.
++It converts fd argument into socket handle internally on Windows,
++so libev should not use Ruby's FD_* utilities.
++
++Following FD_* utilities come from MinGW.
++RubyInstaller is built by MinGW so this should work.
++*/
++int PASCAL __WSAFDIsSet(SOCKET,fd_set*);
++#define EV_WIN_FD_CLR(fd,set) do { u_int __i;\
++for (__i = 0; __i < ((fd_set *)(set))->fd_count ; __i++) {\
++	if (((fd_set *)(set))->fd_array[__i] == (fd)) {\
++	while (__i < ((fd_set *)(set))->fd_count-1) {\
++		((fd_set*)(set))->fd_array[__i] = ((fd_set*)(set))->fd_array[__i+1];\
++		__i++;\
++	}\
++	((fd_set*)(set))->fd_count--;\
++	break;\
++	}\
++}\
++} while (0)
++#define EV_WIN_FD_SET(fd, set) do { u_int __i;\
++for (__i = 0; __i < ((fd_set *)(set))->fd_count ; __i++) {\
++	if (((fd_set *)(set))->fd_array[__i] == (fd)) {\
++		break;\
++	}\
++}\
++if (__i == ((fd_set *)(set))->fd_count) {\
++	if (((fd_set *)(set))->fd_count < FD_SETSIZE) {\
++		((fd_set *)(set))->fd_array[__i] = (fd);\
++		((fd_set *)(set))->fd_count++;\
++	}\
++}\
++} while(0)
++#define EV_WIN_FD_ZERO(set) (((fd_set *)(set))->fd_count=0)
++#define EV_WIN_FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set *)(set))
++/* ######################################## */
++#else
++#define EV_WIN_FD_CLR FD_CLR
++#define EV_WIN_FD_SET FD_SET
++#define EV_WIN_FD_ZERO FD_ZERO
++#define EV_WIN_FD_ISSET FD_ISSET
++#endif
++
+ static void
+ select_modify (EV_P_ int fd, int oev, int nev)
+ {
+@@ -91,17 +138,17 @@ select_modify (EV_P_ int fd, int oev, int nev)
+     if ((oev ^ nev) & EV_READ)
+     #endif
+       if (nev & EV_READ)
+-        FD_SET (handle, (fd_set *)vec_ri);
++        EV_WIN_FD_SET (handle, (fd_set *)vec_ri);
+       else
+-        FD_CLR (handle, (fd_set *)vec_ri);
++        EV_WIN_FD_CLR (handle, (fd_set *)vec_ri);
+ 
+     #if EV_SELECT_IS_WINSOCKET
+     if ((oev ^ nev) & EV_WRITE)
+     #endif
+       if (nev & EV_WRITE)
+-        FD_SET (handle, (fd_set *)vec_wi);
++        EV_WIN_FD_SET (handle, (fd_set *)vec_wi);
+       else
+-        FD_CLR (handle, (fd_set *)vec_wi);
++        EV_WIN_FD_CLR (handle, (fd_set *)vec_wi);
+ 
+ #else
+ 
+@@ -136,6 +183,8 @@ select_modify (EV_P_ int fd, int oev, int nev)
+   }
+ }
+ 
++#undef socket
++
+ static void
+ select_poll (EV_P_ ev_tstamp timeout)
+ {
+@@ -230,10 +279,10 @@ select_poll (EV_P_ ev_tstamp timeout)
+           int handle = fd;
+           #endif
+ 
+-          if (FD_ISSET (handle, (fd_set *)vec_ro)) events |= EV_READ;
+-          if (FD_ISSET (handle, (fd_set *)vec_wo)) events |= EV_WRITE;
++          if (EV_WIN_FD_ISSET (handle, (fd_set *)vec_ro)) events |= EV_READ;
++          if (EV_WIN_FD_ISSET (handle, (fd_set *)vec_wo)) events |= EV_WRITE;
+           #ifdef _WIN32
+-          if (FD_ISSET (handle, (fd_set *)vec_eo)) events |= EV_WRITE;
++          if (EV_WIN_FD_ISSET (handle, (fd_set *)vec_eo)) events |= EV_WRITE;
+           #endif
+ 
+           if (expect_true (events))
+@@ -279,9 +328,9 @@ select_init (EV_P_ int flags)
+   backend_poll    = select_poll;
+ 
+ #if EV_SELECT_USE_FD_SET
+-  vec_ri  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_ri);
++  vec_ri  = ev_malloc (sizeof (fd_set)); EV_WIN_FD_ZERO ((fd_set *)vec_ri);
+   vec_ro  = ev_malloc (sizeof (fd_set));
+-  vec_wi  = ev_malloc (sizeof (fd_set)); FD_ZERO ((fd_set *)vec_wi);
++  vec_wi  = ev_malloc (sizeof (fd_set)); EV_WIN_FD_ZERO ((fd_set *)vec_wi);
+   vec_wo  = ev_malloc (sizeof (fd_set));
+   #ifdef _WIN32
+   vec_eo  = ev_malloc (sizeof (fd_set));

data/lib/.gitignore

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

data/lib/cool.io.rb

@@ -0,0 +1,34 @@
+#--
+# Copyright (C)2011 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require "cool.io/version"
+require "cool.io/custom_require"
+cool_require "iobuffer_ext"
+cool_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"
+
+module Coolio
+  def self.inspect
+    "Cool.io"
+  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/custom_require.rb

@@ -0,0 +1,9 @@
+def cool_require(gem)
+  begin
+    m = /(\d+.\d+)/.match(RUBY_VERSION)
+    ver = m[1]
+    require "#{ver}/#{gem}.so"
+  rescue LoadError
+    require gem
+  end
+end

data/lib/cool.io/dns_resolver.rb

@@ -0,0 +1,219 @@
+#--
+# 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
+#
+#++
+
+require 'resolv'
+
+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
+    #--
+    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 = Resolv::Hosts::DefaultFileName)
+      hosts = {}
+      File.open(hostfile) do |f|
+        f.each_line do |host_entry|
+          entries = host_entry.gsub(/#.*$/, '').gsub(/\s+/, ' ').split(' ')
+          addr = entries.shift
+          entries.each { |e| hosts[e] ||= addr }
+        end
+      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 = Resolv::DNS::Config.default_config_hash[:nameserver]
+        raise RuntimeError, "no nameservers found" 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
+      begin
+        @socket.send request_message, 0, @nameservers.first, DNS_PORT
+      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