rev 0.1.0

data/lib/rev/loop.rb

@@ -0,0 +1,101 @@
+#--
+# 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 Loop
+    attr_reader :watchers
+
+    # Create a new Rev::Loop
+    #
+    # Options:
+    #
+    # :skip_environment (boolean)
+    #   Ignore the $LIBEV_FLAGS environment variable
+    #
+    # :fork_check (boolean)      
+    #   Enable autodetection of forks
+    #
+    # :backend
+    #   Choose the default backend, one (or many in an array) of:
+    #     :select (most platforms)
+    #     :poll   (most platforms except Windows)
+    #     :epoll  (Linux)
+    #     :kqueue (BSD/Mac OS X)
+    #     :port   (Solaris 10)
+    #
+    def initialize(options = {})
+      @watchers = []
+      @active_watchers = 0
+      
+      flags = 0
+
+      options.each do |option, value|
+        case option
+        when :skip_environment
+          flags |= EVFLAG_NOEV if value
+        when :fork_check
+          flags |= EVFLAG_FORKCHECK if value
+        when :backend
+          value = [value] unless value.is_a? Array
+          value.each do |backend|
+            case backend
+            when :select then flags |= EVBACKEND_SELECT
+            when :poll   then flags |= EVBACKEND_POLL
+            when :epoll  then flags |= EVBACKEND_EPOLL
+            when :kqueue then flags |= EVBACKEND_KQUEUE
+            when :port   then flags |= EVBACKEND_PORT
+            else raise ArgumentError, "no such backend: #{backend}"
+            end
+          end
+        else raise ArgumentError, "no such option: #{option}"
+        end
+      end
+
+      @loop = ev_loop_new(flags)
+    end
+    
+    # Attach a watcher to the loop
+    def attach(watcher)
+      watcher.attach self
+    end
+
+    # Run the event loop and dispatch events back to Ruby.  If there
+    # are no watchers associated with the event loop it will return
+    # immediately.  Otherwise, run will continue blocking and making
+    # event callbacks to watchers until all watchers associated with
+    # the loop have been disabled or detached.  The loop may be 
+    # explicitly stopped by calling the stop method on the loop object.
+    def run
+      raise RuntimeError, "no watchers for this loop" if @watchers.empty?
+
+      @running = true
+      while @running and not @active_watchers.zero?
+        run_once
+      end
+    end
+
+    # Stop the event loop if it's running
+    def stop
+      raise RuntimeError, "loop not running" unless @running
+      @running = false
+    end
+    
+    #######
+    private
+    #######
+    
+    EVFLAG_NOENV     = 0x1000000  # do NOT consult environment
+    EVFLAG_FORKCHECK = 0x2000000  # check for a fork in each iteration
+
+    EVBACKEND_SELECT = 0x00000001 # supported about anywhere 
+    EVBACKEND_POLL   = 0x00000002 # !win 
+    EVBACKEND_EPOLL  = 0x00000004 # linux 
+    EVBACKEND_KQUEUE = 0x00000008 # bsd 
+    EVBACKEND_PORT   = 0x00000020 # solaris 10
+  end
+end

data/lib/rev/server.rb

@@ -0,0 +1,53 @@
+#--
+# 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 Server < Listener
+    def initialize(listen_socket, klass = Socket, *args, &block)
+      # Ensure the provided class responds to attach
+      unless (klass.instance_method(:attach) rescue nil)
+        raise ArgumentError, "provided class must respond to 'attach'"
+      end
+
+      # Verify the arity of the provided arguments
+      arity = klass.instance_method(:initialize).arity
+      expected = arity >= 0 ? arity : -(arity + 1)
+
+      if (arity >= 0 and args.size + 1 != expected) or (arity < 0 and args.size + 1 < expected)
+        raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size+1} for #{expected})" 
+      end
+     
+      @klass, @args, @block = klass, args, block
+      super(listen_socket)
+    end
+
+    #########
+    protected
+    #########
+    
+    def on_connection(socket)
+      connection = @klass.new(socket, *@args).attach(evloop)
+      @block.(connection) if @block
+      connection.on_connect
+    end
+  end
+
+  class TCPServer < Server
+    def initialize(host, port, klass = TCPSocket, *args, &block)
+      listen_socket = ::TCPServer.new(host, port)
+      listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
+      super(listen_socket, klass, *args, &block)
+    end
+  end
+
+  class UNIXServer < Server
+    def initialize(path, klass = UNIXSocket, *args, &block)
+      super(::UNIXServer.new(*args), klass, *args, &block)
+    end
+  end
+end

data/lib/rev/socket.rb

@@ -0,0 +1,186 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'socket'
+require 'resolv'
+require File.dirname(__FILE__) + '/../rev'
+
+module Rev
+  class Socket < BufferedIO
+    def self.connect(socket, *args)
+      new(socket, *args).instance_eval {
+        @connector = Connector.new(self, socket)
+        self
+      }
+    end
+    
+    watcher_delegate :@connector
+
+    def attach(evloop)
+      raise RuntimeError, "connection failed" if @failed
+      
+      if @connector
+        @connector.attach(evloop)
+        return self
+      end
+      
+      super
+    end
+
+    # Called upon completion of a socket connection
+    def on_connect; end
+    event_callback :on_connect
+    
+    # Called if a socket connection failed to complete
+    def on_connect_failed; end
+    event_callback :on_connect_failed
+    
+    #########
+    protected
+    #########
+    
+    class Connector < IOWatcher
+      def initialize(rev_socket, ruby_socket)
+        @rev_socket, @ruby_socket = rev_socket, ruby_socket
+        super(ruby_socket, :w)
+      end
+      
+      def on_writable
+        evl = evloop
+        detach
+
+        if connect_successful?
+          @rev_socket.instance_eval { @connector = nil }
+          @rev_socket.attach(evl)
+          @rev_socket.on_connect
+        else
+          @rev_socket.instance_eval { @failed = true }
+          @rev_socket.on_connect_failed
+        end
+      end      
+
+      #######
+      private
+      #######
+
+      def connect_successful?
+        @ruby_socket.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR).unpack('i').first == 0
+      end
+    end
+  end
+  
+  class TCPSocket < Socket
+    attr_reader :remote_host, :remote_addr, :remote_port, :address_family
+    watcher_delegate :@resolver
+    
+    # Perform a non-blocking connect to the given host and port
+    def self.connect(addr, port, *args)
+      family = nil
+
+      if (Resolv::IPv4.create(addr) rescue nil)
+        family = ::Socket::AF_INET
+      elsif(Resolv::IPv6.create(addr) rescue nil)
+        family = ::Socket::AF_INET6
+      end
+ 
+      if family
+        return super(TCPConnectSocket.new(family, addr, port), *args)
+      end
+
+      if host = Rev::DNSResolver.hosts(addr)
+        return connect(host, port, *args)
+      end
+
+      return allocate.instance_eval {
+        @remote_host, @remote_addr, @remote_port = addr, addr, port
+        @resolver = TCPConnectResolver.new(self, addr, port, *args)
+      }
+    end
+    
+    def initialize(socket)
+      unless socket.is_a?(::TCPSocket) or socket.is_a?(TCPConnectSocket)
+        raise TypeError, "socket must be a TCPSocket"
+      end
+      
+      super
+      
+      @address_family, @remote_port, @remote_host, @remote_addr = socket.peeraddr  
+    end
+    
+    #########
+    protected
+    #########
+
+    class TCPConnectSocket < ::Socket
+      def initialize(family, addr, port, host = addr)
+        @host, @addr, @port = host, addr, port
+        @address_family = nil
+
+        @socket = super(family, ::Socket::SOCK_STREAM, 0)
+        begin
+          @socket.connect_nonblock(::Socket.sockaddr_in(port, addr))
+        rescue Errno::EINPROGRESS
+        end
+      end
+
+      def peeraddr
+        [
+          @address_family == ::Socket::AF_INET ? 'AF_INET' : 'AF_INET6',
+          @port,
+          @host,
+          @addr
+        ]
+      end
+    end
+
+    class TCPConnectResolver < Rev::DNSResolver
+      def initialize(socket, host, port, *args)
+        @sock, @host, @port, @args = socket, host, port, args
+        super(host)
+      end
+
+      def on_success(addr)
+        host, port, args = @host, @port, @args
+
+        @sock.instance_eval {
+          # DNSResolver only supports IPv4 so we can safely assume an IPv4 address
+          socket = TCPConnectSocket.new(::Socket::AF_INET, addr, port, host)
+          initialize(socket, *args)
+          @connector = Connector.new(self, socket)
+          @resolver = nil
+        }
+        @sock.attach(evloop)
+      end
+
+      def on_failure
+        @sock.on_connect_failed
+        @sock.instance_eval { 
+          @resolver = nil 
+          @failed = true
+        }
+        return
+      end
+
+      alias_method :on_timeout, :on_failure
+    end
+  end
+  
+  class UNIXSocket < Socket
+    attr_reader :path, :address_family
+    
+    # Connect to the given UNIX domain socket
+    def self.connect(path, *args)
+      new(::UNIXSocket.new(path), *args)
+    end
+    
+    def initialize(socket)
+      raise ArgumentError, "socket must be a UNIXSocket" unless socket.is_a? ::UNIXSocket
+      
+      super
+      @address_family, @path = socket.peeraddr
+    end
+  end
+end

data/lib/rev/timer_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 :timer_watcher
+  end
+end

data/lib/rev/watcher.rb

@@ -0,0 +1,49 @@
+#--
+# 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 Watcher
+    # Use an alternate watcher with the attach/detach/enable/disable methods
+    # if it is presently assigned.  This is useful if you are waiting for
+    # an event to occur before the current watcher can be used in earnest,
+    # such as making an outgoing TCP connection.
+    def self.watcher_delegate(proxy_var)
+      %w{attach detach enable disable}.each do |method|
+        module_eval <<-EOD
+          def #{method}(*args)
+            if #{proxy_var}
+              #{proxy_var}.#{method}(*args)
+              return self
+            end
+
+            super
+          end
+        EOD
+      end
+    end
+
+    # Define callbacks whose behavior can be changed on-the-fly per instance.
+    # This is done by giving a block to the callback method, which is captured
+    # as a proc and stored for later.  If the method is called without a block,
+    # the stored block is executed if present, otherwise it's a noop.
+    def self.event_callback(*methods)
+      methods.each do |method|
+        module_eval <<-EOD
+          def #{method}(*args, &block)
+            if block
+              @#{method}_callback = block
+              return
+            end
+
+            @#{method}_callback.(*([self] + args)) if @#{method}_callback
+          end
+        EOD
+      end
+    end
+  end
+end

data/spec/rev_spec.rb

@@ -0,0 +1,26 @@
+#
+# Oops, were you expecting some real RSpec?
+#
+# I'm sorry to disappoint.  Really, this is pretty damn weak.
+#
+# I swear that after Ruby 1.9 comes out proper, this will become an actual spec
+#
+
+require 'socket'
+require File.dirname(__FILE__) + '/../lib/rev'
+
+class MyWatcher < Rev::IOWatcher
+  def on_readable
+    puts "Yippie, I'm readable!"
+    detach
+  end
+end
+
+listen_socket = TCPServer.new 'localhost', 4321
+watcher = MyWatcher.new(listen_socket)
+event_loop = Rev::Loop.new
+watcher.attach(event_loop)
+
+puts "Running the event loop in blocking mode on localhost port 4321"
+puts "Telnet there or something and you should get a read event"
+event_loop.run

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: rev
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-12-25 00:00:00 -07:00
+summary: Ruby 1.9 binding to the libev high performance event library
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Tony Arcieri
+files: 
+- LICENSE
+- README
+- lib/rev
+- lib/rev/buffered_io.rb
+- lib/rev/dns_resolver.rb
+- lib/rev/io_watcher.rb
+- lib/rev/listener.rb
+- lib/rev/loop.rb
+- lib/rev/server.rb
+- lib/rev/socket.rb
+- lib/rev/timer_watcher.rb
+- lib/rev/watcher.rb
+- lib/rev.rb
+- ext/libev/ev.h
+- ext/libev/ev_vars.h
+- ext/libev/ev_wrap.h
+- ext/rev/rev.h
+- ext/rev/rev_watcher.h
+- ext/libev/ev.c
+- ext/libev/ev_epoll.c
+- ext/libev/ev_kqueue.c
+- ext/libev/ev_poll.c
+- ext/libev/ev_port.c
+- ext/libev/ev_select.c
+- ext/libev/ev_win32.c
+- ext/rev/rev_ext.c
+- ext/rev/rev_io_watcher.c
+- ext/rev/rev_loop.c
+- ext/rev/rev_timer_watcher.c
+- ext/rev/rev_watcher.c
+- ext/rev/extconf.rb
+test_files: 
+- spec/rev_spec.rb
+rdoc_options: 
+- --title
+- Rev
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- LICENSE
+- ext/libev/ev.c
+- ext/libev/ev_epoll.c
+- ext/libev/ev_kqueue.c
+- ext/libev/ev_poll.c
+- ext/libev/ev_port.c
+- ext/libev/ev_select.c
+- ext/libev/ev_win32.c
+- ext/rev/rev_ext.c
+- ext/rev/rev_io_watcher.c
+- ext/rev/rev_loop.c
+- ext/rev/rev_timer_watcher.c
+- ext/rev/rev_watcher.c
+executables: []
+
+extensions: 
+- ext/rev/extconf.rb
+requirements: []
+
+dependencies: []
+