rev 0.1.0

data/ext/rev/rev_watcher.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifndef REV_WATCHER_H
+#define REV_WATCHER_H
+
+#define Watcher_Attach(watcher_type, detach_func, watcher, loop) \
+  struct Rev_Watcher *watcher_data; \
+  struct Rev_Loop *loop_data; \
+  \
+  if(!rb_obj_is_kind_of(loop, cRev_Loop)) \
+    rb_raise(rb_eArgError, "expected loop to be an instance of Rev::Loop"); \
+  \
+  Data_Get_Struct(watcher, struct Rev_Watcher, watcher_data); \
+  Data_Get_Struct(loop, struct Rev_Loop, loop_data); \
+  \
+  if(watcher_data->loop != Qnil) \
+    detach_func(watcher); \
+  \
+  watcher_data->loop = loop; \
+  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  watcher_data->enabled = 1; \
+  rb_call_super(1, &loop)
+
+#define Watcher_Detach(watcher_type, watcher) \
+  struct Rev_Watcher *watcher_data; \
+  struct Rev_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Rev_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Rev_Loop, loop_data); \
+  \
+  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  watcher_data->enabled = 0; \
+  rb_call_super(0, 0)
+
+#define Watcher_Enable(watcher_type, watcher) \
+  struct Rev_Watcher *watcher_data; \
+  struct Rev_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Rev_Watcher, watcher_data); \
+  \
+  if(watcher_data->enabled) \
+    rb_raise(rb_eRuntimeError, "already enabled"); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Rev_Loop, loop_data); \
+  \
+  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  watcher_data->enabled = 1; \
+  rb_call_super(0, 0)
+
+#define Watcher_Disable(watcher_type, watcher) \
+  struct Rev_Watcher *watcher_data; \
+  struct Rev_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Rev_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  if(!watcher_data->enabled) \
+    rb_raise(rb_eRuntimeError, "already disabled"); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Rev_Loop, loop_data); \
+  \
+  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  watcher_data->enabled = 0; \
+  rb_call_super(0, 0)
+
+#endif

data/lib/rev.rb

@@ -0,0 +1,21 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/rev_ext'
+require File.dirname(__FILE__) + '/rev/loop'
+require File.dirname(__FILE__) + '/rev/watcher'
+require File.dirname(__FILE__) + '/rev/io_watcher'
+require File.dirname(__FILE__) + '/rev/timer_watcher'
+require File.dirname(__FILE__) + '/rev/listener'
+require File.dirname(__FILE__) + '/rev/buffered_io'
+require File.dirname(__FILE__) + '/rev/dns_resolver'
+require File.dirname(__FILE__) + '/rev/socket'
+require File.dirname(__FILE__) + '/rev/server'
+
+module Rev
+  Rev::VERSION = '0.1.0' unless defined? Rev::VERSION
+  def self.version() VERSION end
+end

data/lib/rev/buffered_io.rb

@@ -0,0 +1,123 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../rev'
+
+module Rev
+  class BufferedIO < IOWatcher
+    def initialize(io)
+      # Output buffer
+      @write_buffer = ''
+
+      # Coerce the argument into an IO object if possible
+      @io = IO.try_convert(io)
+      super(@io)
+    end
+
+    #
+    # Callbacks for asynchronous events
+    #
+
+    # Called whenever the IO object receives data
+    def on_read(data); end
+    event_callback :on_read
+
+    # Called whenever a write completes and the output buffer is empty
+    def on_write_complete; end
+    event_callback :on_write_complete
+
+    # Called whenever the IO object hits EOF
+    def on_close; end
+    event_callback :on_close
+
+    #
+    # Write interface
+    #
+
+    # Write data in a buffered, non-blocking manner
+    def write(data)
+      # Attempt a zero copy write
+      if @write_buffer.empty?
+        written = @io.write_nonblock data
+
+        # If we lucked out and wrote out the whole buffer, return
+        if written == data.size
+          on_write_complete
+          return data.size
+        end
+
+        # Otherwise append the remaining data to the buffer 
+        @write_buffer << data[written..data.size]
+      else
+        @write_buffer << data
+      end
+
+      schedule_write
+      data.size
+    end
+
+    # Number of bytes are currently in the output buffer
+    def output_buffer_size
+      @write_buffer.size
+    end
+
+    # Attempt to write the contents of the output buffer
+    def write_output_buffer
+      return if @write_buffer.empty?
+
+      written = @io.write_nonblock @write_buffer
+      @write_buffer.slice!(written, @write_buffer.size)
+
+      return unless @write_buffer.empty?
+
+      @writer.disable if @writer and @writer.enabled?
+      on_write_complete
+    end
+    
+    # Close the BufferedIO stream
+    def close
+      detach if attached?
+      @writer.detach if @writer and @writer.attached?
+      @io.close
+
+      on_close
+    end
+
+    #########
+    protected
+    #########
+    
+    # Inherited callback from IOWatcher
+    def on_readable
+      begin
+        on_read @io.read_nonblock(4096)
+      rescue EOFError
+        close
+      end
+    end
+     
+    def schedule_write
+      return if @writer and @writer.enabled?
+      if @writer 
+        @writer.enable
+      else 
+        @writer = Writer.new(@io, self)
+        @writer.attach(evloop)
+      end
+    end
+
+    class Writer < IOWatcher
+      def initialize(io, buffered_io)
+        @buffered_io = buffered_io
+        super(io, :w)
+      end
+
+      def on_writable
+        @buffered_io.write_output_buffer
+      end
+    end
+  end
+end

data/lib/rev/dns_resolver.rb

@@ -0,0 +1,178 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../rev'
+
+#--
+# 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! 
+#++
+
+module Rev
+  class DNSResolver < IOWatcher
+    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
+
+    def self.hosts(host)
+      hosts = {}
+      File.open(HOSTS).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
+
+    def initialize(hostname, *nameservers)
+      if nameservers.nil? or nameservers.empty?
+        nameservers = File.read(RESOLV_CONF).scan(/^\s*nameserver\s+([0-9.:]+)/).flatten
+        raise RuntimeError, "no nameservers found in #{RESOLV_CONF}" if nameservers.empty?
+      end
+
+      @nameservers = nameservers
+      @request = request_message hostname
+      @question = request_question hostname
+
+      @socket = UDPSocket.new
+      @timer = Timeout.new(self)
+      super(@socket)
+    end
+
+    def attach(evloop)
+      send_request
+      @timer.attach(evloop)
+      super
+    end
+
+    def detach
+      @timer.detach if @timer.attached?
+      super
+    end
+
+    # Send a request to the DNS server
+    def send_request
+      @socket.connect @nameservers.first, DNS_PORT
+      @socket.send @request, 0
+    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
+    def on_timeout; end
+    event_callback :on_timeout
+
+    #########
+    protected
+    #########
+    
+    # Called by the subclass when the DNS response is available
+    def on_readable
+      datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
+      address = response_address datagram rescue nil
+      address ? on_success(address) : on_failure
+      detach
+    end
+
+    def request_message(hostname)
+      # Standard query header
+      message = "\000\002\001\000"
+
+      # One entry
+      qdcount = 1
+
+      # No answer, authority, or additional records
+      ancount = nscount = arcount = 0 
+
+      message << [qdcount, ancount, nscount, arcount].pack('nnnn')
+      message << request_question(hostname)
+   end
+
+    def request_question(hostname)
+      # Query name
+      message = hostname.split('.').map { |s| [s.size].pack('C') << s }.join + "\000"
+
+      # Host address query
+      qtype = 1
+
+      # Internet query
+      qclass = 1
+
+      message << [qtype, qclass].pack('nn')
+    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].unpack('B1').first.to_i
+      return unless qr == 1
+
+      # Check the RCODE and ensure there wasn't an error
+      rcode = message[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 = message[12..message.size] # slice! would be nice but I think I hit a 1.9 bug...
+
+      # Make sure it's the same question
+      return unless message[0..(@question.size-1)] == @question
+      message = message[@question.size..message.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 = message[(12+rdlength)..message.size]
+
+        # Only IPv4 supported
+        next unless rdlength == 4
+
+        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
+        return @resolver.send_request if @attempts <= RETRIES 
+        
+        @resolver.on_timeout
+        @resolver.detach
+      end
+    end
+  end
+end

data/lib/rev/io_watcher.rb

@@ -0,0 +1,18 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../rev'
+
+module Rev
+  class IOWatcher
+    # The actual implementation of this class resides in the C extension
+    # Here we metaprogram proper event_callbacks for the callback methods
+    # These can take a block and store it to be called when the event
+    # is actually fired.
+
+    event_callback :on_readable, :on_writable
+  end
+end

data/lib/rev/listener.rb

@@ -0,0 +1,50 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'socket'
+require File.dirname(__FILE__) + '/../rev'
+
+module Rev
+  class Listener < IOWatcher
+    def initialize(listen_socket)
+      @listen_socket = listen_socket
+      super(@listen_socket)
+    end
+
+    # Called whenever the server receives a new connection
+    def on_connection(socket); end
+    event_callback :on_connection
+
+    #########
+    protected
+    #########
+
+    # Rev callback for handling new connections
+    def on_readable
+      on_connection @listen_socket.accept_nonblock
+    end
+  end
+
+  class TCPListener < Listener
+    # Create a new Rev::TCPListener
+    #
+    # Accepts the same arguments as TCPServer.new
+    def initialize(*args)
+      listen_socket = ::TCPServer.new(*args)
+      listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
+      super(listen_socket)
+    end
+  end
+
+  class UNIXListener < Listener
+    # Create a new Rev::UNIXListener
+    #
+    # Accepts the same arguments as UNIXServer.new
+    def initialize(*args)
+      super(::UNIXServer.new(*args))
+    end
+  end
+end