cool.io 1.2.0-x86-mingw32

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/lib/.gitignore

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

data/lib/cool.io.rb

@@ -0,0 +1,32 @@
+#--
+# 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"
+require "cool.io/http_client"
+require "cool.io/dsl"
+
+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,225 @@
+#--
+# 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
+    if RUBY_PLATFORM =~ /mingw|win32/
+      HOSTS = 'c:\WINDOWS\system32\drivers\etc\hosts'
+    else
+      HOSTS = '/etc/hosts'
+    end
+    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) 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?
+        require 'resolv'
+        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
+      @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/dsl.rb

@@ -0,0 +1,135 @@
+#--
+# 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