eventmachine-with-ipv6 1.0.0.beta.4.ipv6.0

data/lib/em/queue.rb

@@ -0,0 +1,71 @@
+module EventMachine
+  # A cross thread, reactor scheduled, linear queue.
+  #
+  # This class provides a simple queue abstraction on top of the reactor
+  # scheduler. It services two primary purposes:
+  #
+  # * API sugar for stateful protocols
+  # * Pushing processing onto the reactor thread
+  #
+  # @example
+  #
+  #  q = EM::Queue.new
+  #  q.push('one', 'two', 'three')
+  #  3.times do
+  #    q.pop { |msg| puts(msg) }
+  #  end
+  #
+  class Queue
+    def initialize
+      @items = []
+      @popq  = []
+    end
+
+    # Pop items off the queue, running the block on the reactor thread. The pop
+    # will not happen immediately, but at some point in the future, either in
+    # the next tick, if the queue has data, or when the queue is populated.
+    #
+    # @return [NilClass] nil
+    def pop(*a, &b)
+      cb = EM::Callback(*a, &b)
+      EM.schedule do
+        if @items.empty?
+          @popq << cb
+        else
+          cb.call @items.shift
+        end
+      end
+      nil # Always returns nil
+    end
+
+    # Push items onto the queue in the reactor thread. The items will not appear
+    # in the queue immediately, but will be scheduled for addition during the
+    # next reactor tick.
+    def push(*items)
+      EM.schedule do
+        @items.push(*items)
+        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
+      end
+    end
+    alias :<< :push
+
+    # @return [Boolean]
+    # @note This is a peek, it's not thread safe, and may only tend toward accuracy.
+    def empty?
+      @items.empty?
+    end
+
+    # @return [Integer] Queue size
+    # @note This is a peek, it's not thread safe, and may only tend toward accuracy.
+    def size
+      @items.size
+    end
+
+    # @return [Integer] Waiting size
+    # @note This is a peek at the number of jobs that are currently waiting on the Queue
+    def num_waiting
+      @popq.size
+    end
+
+  end # Queue
+end # EventMachine

data/lib/em/resolver.rb

@@ -0,0 +1,195 @@
+module EventMachine
+  module DNS
+    class Resolver
+
+      def self.resolve(hostname)
+        Request.new(socket, hostname)
+      end
+
+      @socket = @nameservers = nil
+
+      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 (.+)$/
+              nscandidate = $1.split(/\s+/).first
+              @nameservers << nscandidate unless nscandidate =~ /:/ # stick with IPv4 for now
+            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
+        s = EventMachine::open_datagram_socket('0.0.0.0', 0, self) # FIXME: this is IPv4 only
+        s.send_error_handling = :ERRORHANDLING_REPORT
+        s
+      end
+
+      def initialize
+        @nameserver = nil
+      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

@@ -0,0 +1,84 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 25 Aug 2007
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# 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.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+module EventMachine
+  # Support for Erlang-style processes.
+  #
+  class SpawnedProcess
+    # Send a message to the spawned process
+    def notify *x
+      me = self
+      EM.next_tick {
+        # A notification executes in the context of this
+        # SpawnedProcess object. That makes self and notify
+        # work as one would expect.
+        #
+        y = me.call(*x)
+        if y and y.respond_to?(:pull_out_yield_block)
+          a,b = y.pull_out_yield_block
+          set_receiver a
+          self.notify if b
+        end
+      }
+    end
+    alias_method :resume, :notify
+    alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
+
+    def set_receiver blk
+      (class << self ; self ; end).class_eval do
+        remove_method :call if method_defined? :call
+        define_method :call, blk
+      end
+    end
+
+  end
+
+  # @private
+  class YieldBlockFromSpawnedProcess
+    def initialize block, notify
+      @block = [block,notify]
+    end
+    def pull_out_yield_block
+      @block
+    end
+  end
+
+  # Spawn an erlang-style process
+  def self.spawn &block
+    s = SpawnedProcess.new
+    s.set_receiver block
+    s
+  end
+
+  # @private
+  def self.yield &block
+    return YieldBlockFromSpawnedProcess.new( block, false )
+  end
+
+  # @private
+  def self.yield_and_notify &block
+    return YieldBlockFromSpawnedProcess.new( block, true )
+  end
+end

data/lib/em/streamer.rb

@@ -0,0 +1,118 @@
+module EventMachine
+  # Streams a file over a given connection. Streaming begins once the object is
+  # instantiated. Typically FileStreamer instances are not reused.
+  #
+  # Streaming uses buffering for files larger than 16K and uses so-called fast file reader (a C++ extension)
+  # if available (it is part of eventmachine gem itself).
+  #
+  # @example
+  #
+  #  module FileSender
+  #    def post_init
+  #      streamer = EventMachine::FileStreamer.new(self, '/tmp/bigfile.tar')
+  #      streamer.callback{
+  #        # file was sent successfully
+  #        close_connection_after_writing
+  #      }
+  #    end
+  #  end
+  #
+  #
+  # @author Francis Cianfrocca
+  class FileStreamer
+    include Deferrable
+
+    # Use mapped streamer for files bigger than 16k
+    MappingThreshold = 16384
+    # Wait until next tick to send more data when 50k is still in the outgoing buffer
+    BackpressureLevel = 50000
+    # Send 16k chunks at a time
+    ChunkSize = 16384
+
+    # @param [EventMachine::Connection] connection
+    # @param [String] filename File path
+    #
+    # @option args [Boolean] :http_chunks (false) Use HTTP 1.1 style chunked-encoding semantics.
+    def initialize connection, filename, args = {}
+      @connection = connection
+      @http_chunks = args[:http_chunks]
+
+      if File.exist?(filename)
+        @size = File.size(filename)
+        if @size <= MappingThreshold
+          stream_without_mapping filename
+        else
+          stream_with_mapping filename
+        end
+      else
+        fail "file not found"
+      end
+    end
+
+    # @private
+    def stream_without_mapping filename
+      if @http_chunks
+        @connection.send_data "#{@size.to_s(16)}\r\n"
+        @connection.send_file_data filename
+        @connection.send_data "\r\n0\r\n\r\n"
+      else
+        @connection.send_file_data filename
+      end
+      succeed
+    end
+    private :stream_without_mapping
+
+    # @private
+    def stream_with_mapping filename
+      ensure_mapping_extension_is_present
+
+      @position = 0
+      @mapping = EventMachine::FastFileReader::Mapper.new filename
+      stream_one_chunk
+    end
+    private :stream_with_mapping
+
+    # Used internally to stream one chunk at a time over multiple reactor ticks
+    # @private
+    def stream_one_chunk
+      loop {
+        if @position < @size
+          if @connection.get_outbound_data_size > BackpressureLevel
+            EventMachine::next_tick {stream_one_chunk}
+            break
+          else
+            len = @size - @position
+            len = ChunkSize if (len > ChunkSize)
+
+            @connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
+            @connection.send_data( @mapping.get_chunk( @position, len ))
+            @connection.send_data("\r\n") if @http_chunks
+
+            @position += len
+          end
+        else
+          @connection.send_data "0\r\n\r\n" if @http_chunks
+          @mapping.close
+          succeed
+          break
+        end
+      }
+    end
+
+    #
+    # We use an outboard extension class to get memory-mapped files.
+    # It's outboard to avoid polluting the core distro, but that means
+    # there's a "hidden" dependency on it. The first time we get here in
+    # any run, try to load up the dependency extension. User code will see
+    # a LoadError if it's not available, but code that doesn't require
+    # mapped files will work fine without it. This is a somewhat difficult
+    # compromise between usability and proper modularization.
+    #
+    # @private
+    def ensure_mapping_extension_is_present
+      @@fastfilereader ||= (require 'fastfilereaderext')
+    end
+    private :ensure_mapping_extension_is_present
+
+  end # FileStreamer
+end # EventMachine