revactor 0.1.4 → 0.1.5

data/CHANGES

@@ -1,3 +1,13 @@
+0.1.5:
+
+* Add Revactor::HttpFetcher, a concurrent HTTP fetcher using 
+  Revactor::HttpClient
+
+* Allow Revactor::HttpClient to take a block for requests, and handle
+  closing sockets automatically when the block has been evaluated
+
+* Change Revactor::Filter setup to express initialize args as Tuples
+
 0.1.4:
 
 * Fix bungled 0.1.3 release :(

data/examples/ring.rb

@@ -0,0 +1,40 @@
+# An Actor ring example
+#
+# Here we construct a ring of interconnected Actors which each know the
+# next Actor to send messages to.  Any message sent from the parent Actor
+# is delivered around the ring and back to the parent.
+
+require 'rubygems'
+require 'revactor'
+
+NCHILDREN = 5
+NAROUND = 5
+
+class RingNode
+  extend Actorize
+  
+  def initialize(next_node)
+    loop do
+      Actor.receive do |filter|
+        filter.when(Object) do |msg|
+          puts "#{Actor.current} got #{msg}"
+          next_node << msg
+        end
+      end
+    end
+  end
+end
+
+next_node = Actor.current
+NCHILDREN.times { next_node = RingNode.spawn(next_node) }
+
+next_node << NAROUND
+
+loop do
+  Actor.receive do |filter|
+    filter.when(Object) do |n|
+      exit if n.zero?
+      next_node << n - 1
+    end
+  end
+end

data/examples/trap_exit.rb

@@ -0,0 +1,22 @@
+# An example of trapping exit messages
+#
+# Here we create a new Actor which raises an unhandled exception
+# whenever it receives the :die message.
+#
+# The parent Actor is linked to this one, and is set to trap exits
+# When the child raises the unhandled exception, the exit message
+# is delivered back to the parent.
+
+require 'rubygems'
+require 'revactor'
+
+actor = Actor.spawn_link do
+  Actor.receive do |filter|
+    filter.when(:die) { raise "Aieeee!" }
+  end
+end
+
+Actor.current.trap_exit = true
+
+actor << :die
+p Actor.receive { |filter| filter.when(Object) { |msg| msg } }

data/lib/revactor.rb

@@ -27,12 +27,12 @@ end
 T = Tuple unless defined? T
 
 module Revactor
-  Revactor::VERSION = '0.1.4' unless defined? Revactor::VERSION
+  Revactor::VERSION = '0.1.5' unless defined? Revactor::VERSION
   def self.version() VERSION end
 end
 
 %w{
-  actor scheduler mailbox tcp http_client
+  actor scheduler mailbox tcp unix http_client
   filters/line filters/packet actorize
 }.each do |file|
   require File.dirname(__FILE__) + '/revactor/' + file
@@ -41,6 +41,7 @@ end
 # Place Revactor modules and classes under the Actor namespace
 class Actor
   Actor::TCP = Revactor::TCP unless defined? Actor::TCP
+  Actor::UNIX = Revactor::UNIX unless defined? Actor::UNIX
   Actor::Filter = Revactor::Filter unless defined? Actor::Filter
   Actor::HttpClient = Revactor::HttpClient unless defined? Actor::HttpClient
 end

data/lib/revactor/actor.rb

@@ -141,11 +141,11 @@ class Actor
     def _spawn(*args, &block)
       fiber = Fiber.new do
         block.call(*args)
-        current.instance_eval { @dead = true }
+        current.instance_variable_set :@dead, true
       end
       
       actor = new(fiber)
-      fiber.instance_eval { @_actor = actor }
+      fiber.instance_variable_set :@_actor, actor
     end
   end
   

data/lib/revactor/filters/line.rb

@@ -45,9 +45,9 @@ module Revactor
       
       # Encode lines using the current delimiter
       def encode(*data)
-        data.reduce("") { |str, d| str << d << @delimiter }
+        data.inject("") { |str, d| str << d << @delimiter }
       end
     end
   end
 end
-  
+  

data/lib/revactor/filters/packet.rb

@@ -23,7 +23,7 @@ module Revactor
         @data_size = 0
         
         @mode = :prefix
-        @buffer = Rev::Buffer.new
+        @buffer = IO::Buffer.new
       end
 
       # Callback for processing incoming frames
@@ -49,7 +49,7 @@ module Revactor
 
       # Send a packet with a specified size prefix
       def encode(*data)
-        data.reduce('') do |s, d|
+        data.inject('') do |s, d|
           raise ArgumentError, 'packet too long for prefix length' if d.size >= 256 ** @prefix_size
           s << [d.size].pack(@prefix_size == 2 ? 'n' : 'N') << d
         end

data/lib/revactor/http_client.rb

@@ -27,7 +27,7 @@ module Revactor
     class << self
       def connect(host, port = 80)        
         client = super
-        client.instance_eval { @receiver = Actor.current }
+        client.instance_variable_set :@receiver, Actor.current
         client.attach Rev::Loop.default
       
         Actor.receive do |filter|
@@ -45,13 +45,14 @@ module Revactor
           end
 
           filter.after(TCP::CONNECT_TIMEOUT) do
+            client.close unless client.closed?
             raise TCP::ConnectError, "connection timed out"
           end
         end
       end
       
       # Perform an HTTP request for the given method and return a response object
-      def request(method, uri, options = {}, &block)
+      def request(method, uri, options = {})
         follow_redirects = options.has_key?(:follow_redirects) ? options[:follow_redirects] : true
         uri = URI.parse(uri)
         
@@ -60,17 +61,29 @@ module Revactor
           request_options = uri.is_a?(URI::HTTPS) ? options.merge(:ssl => true) : options
         
           client = connect(uri.host, uri.port)
-          response = client.request(method, uri.request_uri, request_options, &block)
+          response = client.request(method, uri.request_uri, request_options)
+          
+          # Request complete
+          unless follow_redirects and REDIRECT_STATUSES.include? response.status
+            return response unless block_given?
+            
+            begin
+              yield response
+            ensure
+              response.close
+            end
+            
+            return
+          end
           
-          return response unless follow_redirects and REDIRECT_STATUSES.include? response.status
           response.close
           
           location = response.headers['location']
           raise "redirect with no location header: #{uri}" if location.nil?
           
-          # Append host to relative URLs
-          if location[0] == '/'
-            location = "#{uri.scheme}://#{uri.host}" << location
+          # Convert path-based redirects to URIs
+          unless /^[a-z]+:\/\// === location
+            location = "#{uri.scheme}://#{uri.host}" << File.expand_path(location, uri.path)
           end
           
           uri = URI.parse(location)
@@ -235,7 +248,9 @@ module Revactor
       @chunked_encoding = response_header.chunked_encoding?
       
       # Convert header fields hash from LIKE_THIS to like-this
-      @headers = response_header.reduce({}) { |h, (k, v)| h[k.split('_').map(&:downcase).join('-')] = v; h }
+      @headers = response_header.inject({}) do |h, (k, v)| 
+        h[k.split('_').map(&:downcase).join('-')] = v; h
+      end
       
       # Extract Transfer-Encoding if available
       @transfer_encoding = @headers.delete('transfer-encoding')
@@ -344,4 +359,4 @@ module Revactor
       @client.close      
     end
   end
-end
+end

data/lib/revactor/http_fetcher.rb

@@ -0,0 +1,100 @@
+#--
+# Copyright (C)2007 Tony Arcieri
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require 'zlib'
+require 'stringio'
+
+module Revactor
+  # A concurrent HTTP fetcher, implemented using a central dispatcher which
+  # scatters requests to a worker pool.
+  #
+  # The HttpFetcher class is callback-driven and intended for subclassing.
+  # When a request completes successfully, the on_success callback is called.
+  # An on_failure callback represents non-200 HTTP responses, and on_error
+  # delivers any exceptions which occured during the fetch.
+  class HttpFetcher
+    def initialize(nworkers = 8)
+      @_nworkers = nworkers
+      @_workers, @_queue = [], []
+      nworkers.times { @_workers << Worker.spawn(Actor.current) }
+    end
+  
+    def get(url, *args)
+      if @_workers.empty?
+        @_queue << T[url, args]
+      else
+        @_workers.shift << T[:fetch, url, args]
+      end
+    end
+
+    def run
+      while true
+        Actor.receive do |filter|
+          filter.when(T[:ready]) do |_, worker|
+            if @_queue.empty?
+              @_workers << worker
+              on_empty if @_workers.size == @_nworkers
+            else
+              worker << T[:fetch, *@_queue.shift]
+            end
+          end
+
+          filter.when(T[:fetched]) { |_, url, document, args| on_success url, document, *args }
+          filter.when(T[:failed])  { |_, url, status, args| on_failure url, status, *args }
+          filter.when(T[:error])   { |_, url, ex, args| on_error url, ex, *args }
+        end
+      end
+    end
+  
+    def on_success(url, document, *args); end
+    def on_failure(url, status, *args); end
+    def on_error(url, ex, *args); end
+    def on_empty; exit; end
+  
+    class Worker
+      extend Actorize
+    
+      def initialize(fetcher)
+        @fetcher = fetcher      
+        loop { wait_for_request }
+      end
+      
+      def wait_for_request
+        Actor.receive do |filter|
+          filter.when(T[:fetch]) do |_, url, args|
+            begin
+              fetch url, args
+            rescue => ex
+              @fetcher << T[:error, url, ex, args]
+            end
+          
+            # FIXME this should be unnecessary, but the HTTP client "leaks" messages
+            Actor.current.mailbox.clear
+            @fetcher << T[:ready, Actor.current]
+          end
+        end
+      end
+    
+      def fetch(url, args)
+        Actor::HttpClient.get(url, :head => {'Accept-Encoding' => 'gzip'}) do |response|
+          if response.status == 200        
+            @fetcher << T[:fetched, url, decode_body(response), args]
+          else
+            @fetcher << T[:failed, url, response.status, args]
+          end
+        end
+      end
+    
+      def decode_body(response)
+        if response.content_encoding == 'gzip'
+          Zlib::GzipReader.new(StringIO.new(response.body)).read
+        else
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/revactor/scheduler.rb

@@ -58,7 +58,7 @@ class Actor
             handle_exit(actor) if actor.dead?
           rescue FiberError
             # Handle Actors whose Fibers died after being scheduled
-            actor.instance_eval { @dead = true }
+            actor.instance_variable_set :@dead, true
             handle_exit(actor)
           rescue => ex
             handle_exit(actor, ex)

data/lib/revactor/tcp.rb

@@ -12,6 +12,12 @@ module Revactor
     # Number of seconds to wait for a connection
     CONNECT_TIMEOUT = 10
 
+    # Raised when a read from a client or server fails
+    class ReadError < StandardError; end
+
+    # Raised when a write to a client or server fails
+    class WriteError < StandardError; end
+
     # Raised when a connection to a remote server fails
     class ConnectError < StandardError; end
     
@@ -88,7 +94,7 @@ module Revactor
         
           super.instance_eval {
             @active, @controller = options[:active], options[:controller]
-            @filterset = initialize_filter(*options[:filter])
+            @filterset = [*initialize_filter(options[:filter])]
             self
           }
         end
@@ -99,10 +105,10 @@ module Revactor
         
         @active ||= options[:active] || false
         @controller ||= options[:controller] || Actor.current
-        @filterset ||= initialize_filter(*options[:filter])
+        @filterset ||= [*initialize_filter(options[:filter])]
         
         @receiver = @controller
-        @read_buffer = Rev::Buffer.new
+        @read_buffer = IO::Buffer.new
       end
       
       def inspect
@@ -152,7 +158,7 @@ module Revactor
       # Read data from the socket synchronously.  If a length is specified
       # then the call blocks until the given length has been read.  Otherwise
       # the call blocks until it receives any data.
-      def read(length = nil)
+      def read(length = nil, options = {})
         # Only one synchronous call allowed at a time
         raise "already being called synchronously" unless @receiver == @controller
         
@@ -195,12 +201,16 @@ module Revactor
               
               raise EOFError, "connection closed"
             end
+
+            if timeout = options[:timeout]
+              filter.after(timeout) { raise ReadError, "read timed out" }
+            end
           end
         end
       end
       
       # Write data to the socket.  The call blocks until all data has been written.
-      def write(data)
+      def write(data, options = {})
         # Only one synchronous call allowed at a time
         raise "already being called synchronously" unless @receiver == @controller
         
@@ -224,6 +234,10 @@ module Revactor
             @active = false
             raise EOFError, "connection closed"
           end
+
+          if timeout = options[:timeout]
+            filter.after(timeout) { raise WriteError, "write timed out" }
+          end
         end
       end
       
@@ -237,26 +251,26 @@ module Revactor
       # Filter setup
       #
       
-      # Initialize filter change
-      def initialize_filter(*filterset)
-        return filterset if filterset.empty?
-        
-        filterset.map do |filter|
-          case filter
-          when Array
-            name = filter.shift
-            case name
-            when Class
-              name.new(*filter)
-            when Symbol
-              symbol_to_filter(name).new(*filter)
-            else raise ArgumentError, "unrecognized filter type: #{name.class}"
-            end
+      # Initialize filters
+      def initialize_filter(filter)
+        case filter
+        when NilClass
+          []
+        when Tuple
+          name, *args = filter
+          case name
           when Class
-            filter.new
+            name.new(*args)
           when Symbol
-            symbol_to_filter(filter).new
+            symbol_to_filter(name).new(*args)
+          else raise ArgumentError, "unrecognized filter type: #{name.class}"
           end
+        when Array
+          filter.map { |f| initialize_filter f }
+        when Class
+          filter.new
+        when Symbol
+          symbol_to_filter(filter).new
         end
       end
       
@@ -271,8 +285,8 @@ module Revactor
       
       # Decode data through the filter chain
       def decode(data)
-        @filterset.reduce([data]) do |a, filter|
-          a.reduce([]) do |a2, d|
+        @filterset.inject([data]) do |a, filter|
+          a.inject([]) do |a2, d|
             a2 + filter.decode(d)
           end
         end
@@ -280,7 +294,7 @@ module Revactor
       
       # Encode data through the filter chain
       def encode(message)
-        @filterset.reverse.reduce(message) { |m, filter| filter.encode(*m) }
+        @filterset.reverse.inject(message) { |m, filter| filter.encode(*m) }
       end
       
       #

data/lib/revactor/unix.rb

@@ -0,0 +1,400 @@
+#--
+# Copyright (C)2009 Eric Wong
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+module Revactor
+  # The UNIX module holds all Revactor functionality related to the
+  # UNIX domain sockets, including drop-in replacements
+  # for Ruby UNIX Sockets which can operate concurrently using Actors.
+  module UNIX
+    # Number of seconds to wait for a connection
+    CONNECT_TIMEOUT = 10
+
+    # Raised when a connection to a server fails
+    class ConnectError < StandardError; end
+
+    # Connect to the specified path for a UNIX domain socket
+    # Accepts the following options:
+    #
+    #   :active - Controls how data is read from the socket.  See the
+    #             documentation for Revactor::UNIX::Socket#active=
+    #
+    def self.connect(path, options = {})
+      socket = begin
+        Socket.connect path, options
+      rescue SystemCallError
+        raise ConnectError, "connection refused"
+      end
+      socket.attach Rev::Loop.default
+    end
+
+    # Listen on the specified path.  Accepts the following options:
+    #
+    #   :active - Default active setting for new connections.  See the
+    #             documentation Rev::UNIX::Socket#active= for more info
+    #
+    #   :controller - The controlling actor, default Actor.current
+    #
+    #   :filter - An symbol/class or array of symbols/classes which implement
+    #             #encode and #decode methods to transform data sent and
+    #             received data respectively via Revactor::UNIX::Socket.
+    #             See the "Filters" section in the README for more information
+    #
+    def self.listen(path, options = {})
+      Listener.new(path, options).attach(Rev::Loop.default).disable
+    end
+
+    # UNIX socket class, returned by Revactor::UNIX.connect and
+    # Revactor::UNIX::Listener#accept
+    class Socket < Rev::UNIXSocket
+      attr_reader :controller
+
+      class << self
+        # Connect to the specified path. Accepts the following options:
+        #
+        #   :active - Controls how data is read from the socket.  See the
+        #             documentation for #active=
+        #
+        #   :controller - The controlling actor, default Actor.current
+        #
+        #   :filter - An symbol/class or array of symbols/classes which
+        #             implement #encode and #decode methods to transform
+        #             data sent and received data respectively via
+        #             Revactor::UNIX::Socket. See the "Filters" section
+        #             in the README for more information
+        #
+        def connect(path, options = {})
+          options[:active]     ||= false
+          options[:controller] ||= Actor.current
+
+          super.instance_eval {
+            @active, @controller = options[:active], options[:controller]
+            @filterset = [*initialize_filter(options[:filter])]
+            self
+          }
+        end
+      end
+
+      def initialize(socket, options = {})
+        super(socket)
+
+        @active ||= options[:active] || false
+        @controller ||= options[:controller] || Actor.current
+        @filterset ||= [*initialize_filter(options[:filter])]
+
+        @receiver = @controller
+        @read_buffer = IO::Buffer.new
+      end
+
+      def inspect
+        "#<#{self.class}:0x#{object_id.to_s(16)} #@address_family:#@path"
+      end
+
+      # Enable or disable active mode data reception.  State can be any
+      # of the following:
+      #
+      #   true - All received data is sent to the controlling actor
+      #   false - Receiving data is disabled
+      #   :once - A single message will be sent to the controlling actor
+      #           then active mode will be disabled
+      #
+      def active=(state)
+        unless @receiver == @controller
+          raise "cannot change active state during a synchronous call"
+        end
+
+        unless [true, false, :once].include? state
+          raise ArgumentError, "must be true, false, or :once"
+        end
+
+        if [true, :once].include?(state)
+          unless @read_buffer.empty?
+            @receiver << [:unix, self, @read_buffer.read]
+            return if state == :once
+          end
+
+          enable unless enabled?
+        end
+
+        @active = state
+      end
+
+      # Is the socket in active mode?
+      def active?; @active; end
+
+      # Set the controlling actor
+      def controller=(controller)
+        Actor === controller or
+          raise ArgumentError, "controller must be an actor"
+
+        @receiver = controller if @receiver == @controller
+        @controller = controller
+      end
+
+      # Read data from the socket synchronously.  If a length is specified
+      # then the call blocks until the given length has been read.  Otherwise
+      # the call blocks until it receives any data.
+      def read(length = nil)
+        # Only one synchronous call allowed at a time
+        @receiver == @controller or
+          raise "already being called synchronously"
+
+        unless @read_buffer.empty? or (length and @read_buffer.size < length)
+          return @read_buffer.read(length)
+        end
+
+        active = @active
+        @active = :once
+        @receiver = Actor.current
+        enable unless enabled?
+
+        loop do
+          Actor.receive do |filter|
+            filter.when(T[:unix, self]) do |_, _, data|
+              if length.nil?
+                @receiver = @controller
+                @active = active
+                enable if @active
+
+                return data
+              end
+
+              @read_buffer << data
+
+              if @read_buffer.size >= length
+                @receiver = @controller
+                @active = active
+                enable if @active
+
+                return @read_buffer.read(length)
+              end
+            end
+
+            filter.when(T[:unix_closed, self]) do
+              unless @receiver == @controller
+                @receiver = @controller
+                @receiver << T[:unix_closed, self]
+              end
+
+              raise EOFError, "connection closed"
+            end
+          end
+        end
+      end
+
+      # Write data to the socket.  The call blocks until all data has been
+      # written.
+      def write(data)
+        # Only one synchronous call allowed at a time
+        @receiver == @controller or
+          raise "already being called synchronously"
+
+        active = @active
+        @active = false
+        @receiver = Actor.current
+        disable if @active
+
+        super(encode(data))
+
+        Actor.receive do |filter|
+          filter.when(T[:unix_write_complete, self]) do
+            @receiver = @controller
+            @active = active
+            enable if @active and not enabled?
+
+            return data.size
+          end
+
+          filter.when(T[:unix_closed, self]) do
+            @active = false
+            raise EOFError, "connection closed"
+          end
+        end
+      end
+
+      alias_method :<<, :write
+
+      #########
+      protected
+      #########
+
+      #
+      # Filter setup
+      #
+
+      # Initialize filters
+      def initialize_filter(filter)
+        case filter
+        when NilClass
+          []
+        when Tuple
+          name, *args = filter
+          case name
+          when Class
+            name.new(*args)
+          when Symbol
+            symbol_to_filter(name).new(*args)
+          else raise ArgumentError, "unrecognized filter type: #{name.class}"
+          end
+        when Array
+          filter.map { |f| initialize_filter f }
+        when Class
+          filter.new
+        when Symbol
+          symbol_to_filter(filter).new
+        end
+      end
+
+      # Lookup filters referenced as symbols
+      def symbol_to_filter(filter)
+        case filter
+        when :line then Revactor::Filter::Line
+        when :packet then Revactor::Filter::Packet
+        else raise ArgumentError, "unrecognized filter type: #{filter}"
+        end
+      end
+
+      # Decode data through the filter chain
+      def decode(data)
+        @filterset.inject([data]) do |a, filter|
+          a.inject([]) do |a2, d|
+            a2 + filter.decode(d)
+          end
+        end
+      end
+
+      # Encode data through the filter chain
+      def encode(message)
+        @filterset.reverse.inject(message) { |m, filter| filter.encode(*m) }
+      end
+
+      #
+      # Rev::UNIXSocket callback
+      #
+
+      def on_connect
+        @receiver << T[:unix_connected, self]
+      end
+
+      def on_connect_failed
+        @receiver << T[:unix_connect_failed, self]
+      end
+
+      def on_close
+        @receiver << T[:unix_closed, self]
+      end
+
+      def on_read(data)
+        # Run incoming message through the filter chain
+        message = decode(data)
+
+        if message.is_a?(Array) and not message.empty?
+          message.each { |msg| @receiver << T[:unix, self, msg] }
+        elsif message and not message.empty?
+          @receiver << T[:unix, self, message]
+        else return
+        end
+
+        if @active == :once
+          @active = false
+          disable
+        end
+      end
+
+      def on_write_complete
+        @receiver << T[:unix_write_complete, self]
+      end
+    end
+
+    # UNIX Listener returned from Revactor::UNIX.listen
+    class Listener < Rev::UNIXListener
+      attr_reader :controller
+
+      # Listen on the specified path.  Accepts the following options:
+      #
+      #   :active - Default active setting for new connections.  See the
+      #             documentation Rev::UNIX::Socket#active= for more info
+      #
+      #   :controller - The controlling actor, default Actor.current
+      #
+      #   :filter - An symbol/class or array of symbols/classes which implement
+      #             #encode and #decode methods to transform data sent and
+      #             received data respectively via Revactor::UNIX::Socket.
+      #             See the "Filters" section in the README for more information
+      #
+      def initialize(path, options = {})
+        super(path)
+        opts = {
+          :active     => false,
+          :controller => Actor.current
+        }.merge(options)
+
+        @active, @controller = opts[:active], opts[:controller]
+        @filterset = options[:filter]
+
+        @accepting = false
+      end
+
+      def inspect
+        "#<#{self.class}:0x#{object_id.to_s(16)}>"
+      end
+
+      # Change the default active setting for newly accepted connections
+      def active=(state)
+        unless [true, false, :once].include? state
+          raise ArgumentError, "must be true, false, or :once"
+        end
+
+        @active = state
+      end
+
+      # Will newly accepted connections be active?
+      def active?; @active; end
+
+      # Change the default controller for newly accepted connections
+      def controller=(controller)
+        Actor === controller or
+          raise ArgumentError, "controller must be an actor"
+        @controller = controller
+      end
+
+      # Accept an incoming connection
+      def accept
+        raise "another actor is already accepting" if @accepting
+
+        @accepting = true
+        @receiver = Actor.current
+        enable
+
+        Actor.receive do |filter|
+          filter.when(T[:unix_connection, self]) do |_, _, sock|
+            @accepting = false
+            return sock
+          end
+        end
+      end
+
+      #########
+      protected
+      #########
+
+      #
+      # Rev::UNIXListener callbacks
+      #
+
+      def on_connection(socket)
+        sock = Socket.new(socket,
+          :controller => @controller,
+          :active => @active,
+          :filter => @filterset
+        )
+        sock.attach(evloop)
+
+        @receiver << T[:unix_connection, self, sock]
+        disable
+      end
+    end
+  end
+end

data/revactor.gemspec

@@ -2,10 +2,10 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "revactor"
-  s.version = "0.1.4"
+  s.version = "0.1.5"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2008-3-28"
+  s.date = "2008-5-27"
   s.summary = "Revactor is an Actor implementation for writing high performance concurrent programs"
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>= 1.9.0'
@@ -14,7 +14,7 @@ GEMSPEC = Gem::Specification.new do |s|
   s.files = Dir.glob("{lib,examples,tools,spec}/**/*") + ['Rakefile', 'revactor.gemspec']
 
   # Dependencies
-  s.add_dependency("rev", ">= 0.2.0")
+  s.add_dependency("rev", ">= 0.3.1")
   s.add_dependency("case", ">= 0.4")
 
   # RubyForge info

data/spec/actor_spec.rb

@@ -4,7 +4,7 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../lib/revactor/actor'
+require File.dirname(__FILE__) + '/../lib/revactor'
 
 describe Actor do
   describe "creation" do
@@ -156,4 +156,4 @@ describe Actor do
     Actor.sleep 0
     actor.dead?.should be_true
   end
-end
+end

data/spec/line_filter_spec.rb

@@ -31,6 +31,6 @@ describe Revactor::Filter::Line do
     chunks[2] = msg2.slice(1, msg2.size - 1)
     chunks[3] = msg2.slice(msg2.size, 1) << msg3
         
-    chunks.reduce([]) { |a, chunk| a + @filter.decode(chunk) }.should == %w{foobar baz quux}
+    chunks.inject([]) { |a, chunk| a + @filter.decode(chunk) }.should == %w{foobar baz quux}
   end
 end

data/spec/packet_filter_spec.rb

@@ -48,7 +48,7 @@ describe Revactor::Filter::Packet do
     chunks[2] = packet2.slice(1, packet2.size - 1)
     chunks[3] = packet2.slice(packet2.size, 1) << packet3
     
-    chunks.reduce([]) { |a, chunk| a + filter.decode(chunk) }.should == [msg1, msg2, msg3]
+    chunks.inject([]) { |a, chunk| a + filter.decode(chunk) }.should == [msg1, msg2, msg3]
   end
 
   it "raises an exception for overlength frames" do

data/spec/tcp_spec.rb

@@ -4,7 +4,7 @@
 # See file LICENSE for details
 #++
 
-require File.dirname(__FILE__) + '/../lib/revactor/tcp'
+require File.dirname(__FILE__) + '/../lib/revactor'
 
 TEST_HOST = '127.0.0.1'
 
@@ -52,6 +52,29 @@ describe Revactor::TCP do
     s1.close
   end
 
+  it "times out on read" do
+    s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+    s2 = @server.accept
+
+    proc {
+      s1.read(6, :timeout => 0.1)
+    }.should raise_error(Revactor::TCP::ReadError)
+
+    s1.close
+  end
+
+  it "times out on write" do
+    s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+    s2 = @server.accept
+
+    # typically needs to write several thousand kilobytes before it blocks
+    buf = ' ' * 16384
+    proc {
+      loop { s1.write(buf, :timeout => 0.1) }
+    }.should raise_error(Revactor::TCP::WriteError)
+    s1.close
+  end
+
   it "writes data" do
     s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
     s2 = @server.accept
@@ -61,4 +84,4 @@ describe Revactor::TCP do
     
     s1.close
   end
-end
+end

data/spec/unix_spec.rb

@@ -0,0 +1,65 @@
+#--
+# Copyright (C)2009 Eric Wong
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/../lib/revactor'
+require 'tempfile'
+
+describe Revactor::UNIX do
+  before :each do
+    @actor_run = false
+    @tmp = Tempfile.new('unix.sock')
+    File.unlink(@tmp.path)
+    @server = UNIXServer.new(@tmp.path)
+  end
+
+  after :each do
+    @server.close unless @server.closed?
+    File.unlink(@tmp.path)
+  end
+
+  it "connects to remote servers" do
+    sock = Revactor::UNIX.connect(@tmp.path)
+    sock.should be_an_instance_of(Revactor::UNIX::Socket)
+    @server.accept.should be_an_instance_of(UNIXSocket)
+
+    sock.close
+  end
+
+  it "listens for remote connections" do
+    # Don't use their server for this one...
+    @server.close
+    File.unlink(@tmp.path)
+
+    server = Revactor::UNIX.listen(@tmp.path)
+    server.should be_an_instance_of(Revactor::UNIX::Listener)
+
+    s1 = UNIXSocket.open(@tmp.path)
+    s2 = server.accept
+
+    server.close
+    s2.close
+  end
+
+  it "reads data" do
+    s1 = Revactor::UNIX.connect(@tmp.path)
+    s2 = @server.accept
+
+    s2.write 'foobar'
+    s1.read(6).should == 'foobar'
+
+    s1.close
+  end
+
+  it "writes data" do
+    s1 = Revactor::UNIX.connect(@tmp.path)
+    s2 = @server.accept
+
+    s1.write 'foobar'
+    s2.read(6).should == 'foobar'
+
+    s1.close
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: revactor
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -9,20 +9,22 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-28 00:00:00 -06:00
+date: 2008-05-27 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rev
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.2.0
+        version: 0.3.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: case
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -41,27 +43,29 @@ extra_rdoc_files:
 - README
 - CHANGES
 files: 
-- lib/revactor
 - lib/revactor/actor.rb
 - lib/revactor/actorize.rb
-- lib/revactor/filters
 - lib/revactor/filters/line.rb
 - lib/revactor/filters/packet.rb
 - lib/revactor/http_client.rb
+- lib/revactor/http_fetcher.rb
 - lib/revactor/mailbox.rb
 - lib/revactor/mongrel.rb
 - lib/revactor/scheduler.rb
 - lib/revactor/tcp.rb
+- lib/revactor/unix.rb
 - lib/revactor.rb
 - examples/chat_server.rb
 - examples/echo_server.rb
 - examples/google.rb
 - examples/mongrel.rb
+- examples/ring.rb
+- examples/trap_exit.rb
 - spec/actor_spec.rb
-- spec/delegator_spec.rb
 - spec/line_filter_spec.rb
 - spec/packet_filter_spec.rb
 - spec/tcp_spec.rb
+- spec/unix_spec.rb
 - Rakefile
 - revactor.gemspec
 - LICENSE
@@ -69,6 +73,8 @@ files:
 - CHANGES
 has_rdoc: true
 homepage: http://revactor.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
@@ -93,9 +99,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: revactor
-rubygems_version: 1.0.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Revactor is an Actor implementation for writing high performance concurrent programs
 test_files: []
 

data/spec/delegator_spec.rb

@@ -1,46 +0,0 @@
-#--
-# 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__) + '/../lib/revactor'
-
-describe Actor::Delegator do
-  before :each do
-    @obj = mock(:obj)
-    @delegator = Actor::Delegator.new(@obj)
-  end
-  
-  it "delegates calls to the given object" do
-    @obj.should_receive(:foo).with(1)
-    @obj.should_receive(:bar).with(2)
-    @obj.should_receive(:baz).with(3)
-    
-    @delegator.foo(1)
-    @delegator.bar(2)
-    @delegator.baz(3)
-  end
-  
-  it "returns the value from calls to the delegate object" do
-    input_value = 42
-    output_value = 420
-    
-    @obj.should_receive(:spiffy).with(input_value).and_return(input_value * 10)
-    @delegator.spiffy(input_value).should == output_value
-  end
-  
-  it "captures exceptions in the delegate and raises them for the caller" do
-    ex = "crash!"
-    
-    @obj.should_receive(:crashy_method).and_raise(ex)
-    proc { @delegator.crashy_method }.should raise_error(ex)
-  end
-  
-  it "passes blocks along to the delegate" do
-    prc = proc { "yay" }
-    
-    @obj.should_receive(:blocky).with(&prc)
-    @delegator.blocky(&prc)
-  end
-end