eventmachine 1.0.0.beta.2-x86-mswin32-60 → 1.0.0.beta.3-x86-mswin32-60

data/lib/em/resolver.rb

@@ -0,0 +1,186 @@
+module EventMachine
+  module DNS
+    class Resolver
+
+      def self.resolve(hostname)
+        Request.new(socket, hostname)
+      end
+
+      def self.socket
+        if !@socket || (@socket && @socket.error?)
+          @socket = Socket.open
+
+          @hosts  = {}
+          IO.readlines('/etc/hosts').each do |line|
+            next if line =~ /^#/
+            addr, host = line.split(/\s+/)
+
+            if @hosts[host]
+              @hosts[host] << addr
+            else
+              @hosts[host] = [addr]
+            end
+          end
+        end
+
+        @socket
+      end
+
+      def self.nameservers=(ns)
+        @nameservers = ns
+      end
+
+      def self.nameservers
+        if !@nameservers
+          @nameservers = []
+          IO.readlines('/etc/resolv.conf').each do |line|
+            if line =~ /^nameserver (.+)$/
+              @nameservers << $1.split(/\s+/).first
+            end
+          end
+        end
+        @nameservers
+      end
+
+      def self.nameserver
+        nameservers.shuffle.first
+      end
+
+      def self.hosts
+        @hosts
+      end
+    end
+
+    class RequestIdAlreadyUsed < RuntimeError; end
+
+    class Socket < EventMachine::Connection
+      def self.open
+        EventMachine::open_datagram_socket('0.0.0.0', 0, self)
+      end
+
+      def post_init
+        @requests = {}
+        EM.add_periodic_timer(0.1, &method(:tick))
+      end
+
+      def unbind
+      end
+
+      def tick
+        @requests.each do |id,req|
+          req.tick
+        end
+      end
+
+      def register_request(id, req)
+        if @requests.has_key?(id)
+          raise RequestIdAlreadyUsed
+        else
+          @requests[id] = req
+        end
+      end
+
+      def send_packet(pkt)
+        send_datagram(pkt, nameserver, 53)
+      end
+
+      def nameserver=(ns)
+        @nameserver = ns
+      end
+
+      def nameserver
+        @nameserver || Resolver.nameserver
+      end
+
+      # Decodes the packet, looks for the request and passes the
+      # response over to the requester
+      def receive_data(data)
+        msg = nil
+        begin
+          msg = Resolv::DNS::Message.decode data
+        rescue
+          else
+            req = @requests[msg.id]
+            if req
+              @requests.delete(msg.id)
+              req.receive_answer(msg)
+            end
+          end
+        end
+      end
+
+      class Request
+        include Deferrable
+        attr_accessor :retry_interval, :max_tries
+
+        def initialize(socket, hostname)
+          @socket = socket
+          @hostname = hostname
+          @tries = 0
+          @last_send = Time.at(0)
+          @retry_interval = 3
+          @max_tries = 5
+
+          if addrs = Resolver.hosts[hostname]
+            succeed addrs
+          else
+            EM.next_tick { tick }
+          end
+        end
+
+        def tick
+          # Break early if nothing to do
+          return if @last_send + @retry_interval > Time.now
+          if @tries < @max_tries
+            send
+          else
+            fail 'retries exceeded'
+          end
+        end
+
+        def receive_answer(msg)
+          addrs = []
+          msg.each_answer do |name,ttl,data|
+            if data.kind_of?(Resolv::DNS::Resource::IN::A) ||
+                data.kind_of?(Resolv::DNS::Resource::IN::AAAA)
+              addrs << data.address.to_s
+            end
+          end
+
+          if addrs.empty?
+            fail "rcode=#{msg.rcode}"
+          else
+            succeed addrs
+          end
+        end
+
+        private
+
+          def send
+            @tries += 1
+            @last_send = Time.now
+            @socket.send_packet(packet.encode)
+          end
+
+          def id
+            begin
+              @id = rand(65535)
+              @socket.register_request(@id, self)
+            rescue RequestIdAlreadyUsed
+              retry
+            end unless defined?(@id)
+
+            @id
+          end
+
+          def packet
+            msg = Resolv::DNS::Message.new
+            msg.id = id
+            msg.rd = 1
+            msg.add_question @hostname, Resolv::DNS::Resource::IN::A
+            msg
+          end
+
+      end
+    end
+  end

data/lib/em/spawnable.rb

@@ -45,15 +45,11 @@ module EventMachine
     end
     alias_method :resume, :notify
     alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
-    #attr_accessor :receiver
 
-    #--
-    # I know I'm missing something stupid, but the inside of class << s
-    # can't see locally-bound values. It can see globals, though.
     def set_receiver blk
-      $em______tmpglobal = blk
-      class << self
-        define_method :call, $em______tmpglobal.dup
+      (class << self ; self ; end).class_eval do
+        remove_method :call if method_defined? :call
+        define_method :call, blk
       end
     end
 

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.0.beta.2"
+  VERSION = "1.0.0.beta.3"
 end

data/lib/eventmachine.rb

@@ -12,7 +12,7 @@ else
   end
 end
 
-require "em/version"
+require 'em/version'
 require 'em/deferrable'
 require 'em/future'
 require 'em/streamer'
@@ -29,9 +29,11 @@ require 'em/channel'
 require 'em/file_watch'
 require 'em/process_watch'
 require 'em/tick_loop'
+require 'em/resolver'
 
 require 'shellwords'
 require 'thread'
+require 'resolv'
 
 # == Introduction
 # EventMachine provides a fast, lightweight framework for implementing
@@ -122,7 +124,7 @@ require 'thread'
 # Interesting thought.
 #
 module EventMachine
-  class <<self
+  class << self
     # Exposed to allow joining on the thread, when run in a multithreaded
     # environment. Performing other actions on the thread has undefined
     # semantics.
@@ -1373,7 +1375,7 @@ module EventMachine
           @wrapped_exception = $!
           EM.stop
         else
-          raise ConnectionNotBound, "recieved ConnectionUnbound for an unknown signature: #{conn_binding}"
+          raise ConnectionNotBound, "received ConnectionUnbound for an unknown signature: #{conn_binding}"
         end
       end
     elsif opcode == ConnectionAccepted
@@ -1545,4 +1547,4 @@ end # module EventMachine
 
 # Save everyone some typing.
 EM = EventMachine
-EM::P = EventMachine::Protocols
+EM::P = EventMachine::Protocols

data/lib/jeventmachine.rb

@@ -187,7 +187,7 @@ module EventMachine
   end
   def self.get_peername sig
     if peer = @em.getPeerName(sig)
-      Socket.pack_sockaddr_in *peer
+      Socket.pack_sockaddr_in(*peer)
     end
   end
   def self.attach_fd fileno, watch_mode

data/tasks/package.rake

@@ -24,10 +24,12 @@ else
 
   Rake::ExtensionTask.new("rubyeventmachine", GEMSPEC) do |ext|
     ext.ext_dir = 'ext'
+    ext.source_pattern = '*.{h,c,cpp}'
     setup_cross_compilation(ext)
   end
   Rake::ExtensionTask.new("fastfilereaderext", GEMSPEC) do |ext|
     ext.ext_dir = 'ext/fastfilereader'
+    ext.source_pattern = '*.{h,c,cpp}'
     setup_cross_compilation(ext)
   end
 end
@@ -47,7 +49,8 @@ end
 
 task :cross_cxx do
   ENV['CROSS_COMPILING'] = 'yes'
-  ENV['CXX'] = 'i386-mingw32-g++'
+  require 'rake/extensioncompiler'
+  ENV['CXX'] = "#{Rake::ExtensionCompiler.mingw_host}-g++"
 end
 
 if Rake::Task.task_defined?(:cross)

data/tasks/test.rake

@@ -1,6 +1,7 @@
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
+  t.libs << "tests"
   t.pattern = 'tests/**/test_*.rb'
   t.warning = true
 end

data/tests/em_test_helper.rb

@@ -0,0 +1,55 @@
+require 'lib/eventmachine'
+require 'test/unit'
+require 'rbconfig'
+require 'socket'
+
+Test::Unit::TestCase.class_eval do
+  class EMTestTimeout < StandardError ; end
+
+  def setup_timeout(timeout = TIMEOUT_INTERVAL)
+    EM.schedule {
+      EM.add_timer(timeout) {
+        raise EMTestTimeout, "Test was cancelled after #{timeout} seconds."
+      }
+    }
+  end
+
+  def port_in_use?(port, host="127.0.0.1")
+    s = TCPSocket.new(host, port)
+    s.close
+    s
+  rescue Errno::ECONNREFUSED
+    false
+  end
+
+  def next_port
+    @@port ||= 9000
+    begin
+      @@port += 1
+    end while port_in_use?(@@port)
+
+    @@port
+  end
+
+  def exception_class
+    jruby? ? NativeException : RuntimeError
+  end
+
+  module PlatformHelper
+    # http://blog.emptyway.com/2009/11/03/proper-way-to-detect-windows-platform-in-ruby/
+    def windows?
+      Config::CONFIG['host_os'] =~ /mswin|mingw/
+    end
+
+    # http://stackoverflow.com/questions/1342535/how-can-i-tell-if-im-running-from-jruby-vs-ruby/1685970#1685970
+    def jruby?
+      defined? JRUBY_VERSION
+    end
+  end
+
+  include PlatformHelper
+  extend PlatformHelper
+
+  # Tests run significantly slower on windows. YMMV
+  TIMEOUT_INTERVAL = windows? ? 1 : 0.25
+end

data/tests/test_attach.rb

@@ -1,31 +1,7 @@
-# $Id$
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-#
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-
-$:.unshift "../lib"
-require 'eventmachine'
+require 'em_test_helper'
 require 'socket'
-require 'test/unit'
-
 
 class TestAttach < Test::Unit::TestCase
-
-  Host = "127.0.0.1"
-  Port = 9550
-
   class EchoServer < EM::Connection
     def receive_data data
       send_data data
@@ -33,47 +9,51 @@ class TestAttach < Test::Unit::TestCase
   end
 
   class EchoClient < EM::Connection
-    def initialize
+    def initialize socket
       self.notify_readable = true
-      $sock.write("abc\n")
+      @socket = socket
+      @socket.write("abc\n")
     end
 
     def notify_readable
-      $read = $sock.readline
+      $read = @socket.readline
       $fd = detach
     end
 
     def unbind
       EM.next_tick do
-        $sock.write("def\n")
-        EM.add_timer(0.1){ EM.stop }
+        @socket.write("def\n")
+        EM.add_timer(0.1) { EM.stop }
       end
     end
   end
 
   def setup
-    $read, $write, $sock, $r, $w, $fd, $sock, $before, $after = nil
+    @port = next_port
+    $read, $r, $w, $fd = nil
   end
 
   def teardown
-    [$read, $write, $sock, $r, $w, $fd, $sock, $before, $after].each do |io|
+    [$r, $w].each do |io|
       io.close rescue nil
     end
   end
 
   def test_attach
-    EM.run{
-      EM.start_server Host, Port, EchoServer
-      $sock = TCPSocket.new Host, Port
-      EM.watch $sock, EchoClient
+    socket = nil
+
+    EM.run {
+      EM.start_server "127.0.0.1", @port, EchoServer
+      socket = TCPSocket.new "127.0.0.1", @port
+      EM.watch socket, EchoClient, socket
     }
 
     assert_equal $read, "abc\n"
-    unless defined? JRuby # jruby filenos are not real
-      assert_equal $fd, $sock.fileno
+    unless jruby? # jruby filenos are not real
+      assert_equal $fd, socket.fileno
     end
-    assert_equal false, $sock.closed?
-    assert_equal $sock.readline, "def\n"
+    assert_equal false, socket.closed?
+    assert_equal socket.readline, "def\n"
   end
 
   module PipeWatch
@@ -96,6 +76,8 @@ class TestAttach < Test::Unit::TestCase
   end
 
   def test_set_readable
+    before, after = nil
+
     EM.run{
       $r, $w = IO.pipe
       c = EM.watch $r, PipeWatch do |con|
@@ -103,34 +85,42 @@ class TestAttach < Test::Unit::TestCase
       end
 
       EM.next_tick{
-        $before = c.notify_readable?
+        before = c.notify_readable?
         c.notify_readable = true
-        $after = c.notify_readable?
+        after = c.notify_readable?
       }
 
       $w.write("jkl\n")
     }
 
-    assert !$before
-    assert $after
+    assert !before
+    assert after
     assert_equal $read, "jkl\n"
   end
 
-  module PipeReader
-    def receive_data data
-      $read = data
-      EM.stop
+  def test_read_write_pipe
+    result = nil
+
+    pipe_reader = Module.new do
+      define_method :receive_data do |data|
+        result = data
+        EM.stop
+      end
     end
-  end
 
-  def test_read_write_pipe
-    EM.run{
-      $r, $w = IO.pipe
-      EM.attach $r, PipeReader
-      writer = EM.attach($w)
+    r,w = IO.pipe
+
+    EM.run {
+      EM.attach r, pipe_reader
+      writer = EM.attach(w)
       writer.send_data 'ghi'
+
+      # XXX: Process will hang in Windows without this line
+      writer.close_connection_after_writing
     }
 
-    assert_equal $read, "ghi"
+    assert_equal "ghi", result
+  ensure
+    [r,w].each {|io| io.close rescue nil }
   end
-end
+end