revactor 0.1.2 → 0.1.3

data/CHANGES

@@ -1,3 +1,20 @@
+0.1.3:
+
+* Removed case gem usage in Revactor internals
+
+* Add a guaranteed blocking idle state for the Actor scheduler, fixing a bug
+  where an idle root Actor would spin on the scheduler when calling receive
+
+* Fixed bug where subclasses of Actor still create Actors when spawned
+
+* Implement initial HttpClient on top of Rev::HttpClient
+
+* Optimize scheduler loop and message dispatch for a 25% speed boost
+
+* Fix bug with the toplevel Actor never resuming if a newly spawend Actor
+  registeres interest in Rev events.  Toplevel Actor is now rescheduled if
+  the event loop isn't running.
+
 0.1.2:
 
 * Change Revactor::TCP::Socket#active to #active? (same for Listener)

data/README

@@ -350,12 +350,9 @@ Revactor is still in its infancy.  Erlang and its Open Telcom Platform are an
 extremely feature rich platform, and many features can be borrowed and
 incorporated into Revactor.
 
-The first and foremost feature to be added is the concept of linked Actors.
-This idea is somewhat difficult to explain for the uninitiated, but the general
-concept is that interdependent Actors are linked in a graph.  When one Actor
-dies, it kills all linked Actors is well.  However, special Actors trap the
-exit messages from the Actors they're linked with.  These Actors are generally
-supervisors and restart any linked Actor graphs which crash.
+Short term goals include adding thread safety.  This will allow Actors in
+different threads to send meassages to each other, making it easy to spin off
+long-term blocking tasks into separate threads.
 
 Next on the agenda is implementing DRb.  This should be possible simply by
 monkeypatching the existing DRb implementation to run on top of Revactor::TCP.
@@ -363,10 +360,6 @@ Once DRb has been implemented it should be fairly trivial to implement
 distributed Actor networks over TCP using DRb as the underlying message
 passing protocol.
 
-Long term items include implementation of more Filters, Behaviors, and protocol
+Long term items include implementation of more Filters and protocol support
 modules.  These include an HTTP client (subclassed from the client in Rev),
-an HTTP server adapter (using the Mongrel parser), and the gen_fsm behavior from
-Erlang.  Additional areas of concern are addressing the problems of mutable 
-state in conjunction with Server and FSM behaviors.  A possible solution is
-to implement a tuple which stores immutable collections of primitive types
-like numbers, strings, and symbols, but this approach is likely to be slow.
+as well as an HTTP server adapter (using the Mongrel parser).

data/examples/chat_server.rb

@@ -0,0 +1,93 @@
+#
+# A simple chat server implemented using 1 <-> N actors 
+# 1 server, N client managers, plus a listener
+#
+# The server handles all message formatting, traffic routing, and connection tracking
+# Client managers handle connection handshaking as well as low-level network interaction
+# The listener spawns new client managers for each incoming connection
+#
+
+require File.dirname(__FILE__) + '/../lib/revactor'
+
+HOST = 'localhost'
+PORT = 4321
+
+# Open a listen socket.  All traffic on new connections will be run through
+# the "line" filter, so incoming messages are delimited by newlines.
+
+listener = Actor::TCP.listen(HOST, PORT, :filter => :line)
+puts "Listening on #{HOST}:#{PORT}"
+
+# Spawn the server
+server = Actor.spawn do
+  clients = {}
+  
+  # A proc to broadcast a message to all connected clients.  If the server
+  # were encapsulated into an object this could be a method
+  broadcast = proc do |msg|
+    clients.keys.each { |client| client << T[:write, msg] }
+  end
+  
+  # Server's main loop.  The server handles incoming messages from the
+  # client managers and dispatches them to other client managers.
+  loop do 
+    Actor.receive do |filter|
+      filter.when(T[:register]) do |_, client, nickname|
+        clients[client] = nickname
+        broadcast.call "*** #{nickname} joined"
+        client << T[:write, "*** Users: " + clients.values.join(', ')]
+      end
+
+      filter.when(T[:say]) do |_, client, msg|
+        nickname = clients[client]
+        broadcast.call "<#{nickname}> #{msg}"
+      end
+
+      filter.when(T[:disconnected]) do |_, client|
+        nickname = clients.delete client
+        broadcast.call "*** #{nickname} left" if nickname
+      end
+    end
+  end
+end
+
+# The main loop handles incoming connections
+loop do
+  # Spawn a new actor for each incoming connection
+  Actor.spawn(listener.accept) do |sock|
+    puts "#{sock.remote_addr}:#{sock.remote_port} connected"
+
+    # Connection handshaking
+    sock.write "Please enter a nickname:"
+    nickname = sock.read
+
+    server << T[:register, Actor.current, nickname]
+    
+    # Flip the socket into asynchronous "active" mode
+    # This means the Actor can receive messages from
+    # the socket alongside other events.
+    sock.controller = Actor.current
+    sock.active = :once
+  
+    # Main message loop
+    loop do
+      Actor.receive do |filter|
+        filter.when(T[:tcp, sock]) do |_, _, message|
+          server << T[:say, Actor.current, message]
+          sock.active = :once
+        end
+        
+        filter.when(T[:write]) do |_, message|
+          sock.write message
+        end
+        
+        filter.when(T[:tcp_closed, sock]) do
+          raise EOFError
+        end
+      end
+    end
+  rescue EOFError
+    puts "#{sock.remote_addr}:#{sock.remote_port} disconnected"
+    server << T[:disconnected, Actor.current]
+  end
+end

data/examples/mongrel.rb

@@ -5,10 +5,8 @@ require File.dirname(__FILE__) + '/../lib/revactor/mongrel'
 ADDR = '127.0.0.1'
 PORT = 8080
 
-Actor.spawn do
-  server = Mongrel::HttpServer.new(ADDR, PORT)
-  server.register '/', Mongrel::DirHandler.new(".")
-  server.run
+server = Mongrel::HttpServer.new(ADDR, PORT)
+server.register '/', Mongrel::DirHandler.new(".")
 
-  puts "Running on #{ADDR}:#{PORT}"
-end
+puts "Running on #{ADDR}:#{PORT}"
+server.start

data/lib/revactor.rb

@@ -5,7 +5,6 @@
 #++
 
 require 'rev'
-require 'case'
 
 # This is mostly in hopes of a bright future with Rubinius
 # The recommended container for all datagrams sent between
@@ -14,18 +13,27 @@ unless defined? Tuple
   # A Tuple class.  Will (eventually) be a subset of Array
   # with fixed size and faster performance, at least that's
   # the hope with Rubinius...
-  class Tuple < Array; end
+  class Tuple < Array
+    def ===(obj)
+      return false unless obj.is_a? Array
+      size.times { |n| return false unless self[n] === obj[n] }
+      true
+    end
+  end
 end
 
 # Shortcut Tuple as T
 T = Tuple unless defined? T
 
 module Revactor
-  Revactor::VERSION = '0.1.2' unless defined? Revactor::VERSION
+  Revactor::VERSION = '0.1.3' unless defined? Revactor::VERSION
   def self.version() VERSION end
 end
 
-%w{actor scheduler mailbox delegator tcp filters/line filters/packet}.each do |file|
+%w{
+  actor scheduler mailbox delegator tcp http_client
+  filters/line filters/packet
+}.each do |file|
   require File.dirname(__FILE__) + '/revactor/' + file
 end
 
@@ -34,4 +42,5 @@ class Actor
   Actor::TCP = Revactor::TCP unless defined? Actor::TCP
   Actor::Filter = Revactor::Filter unless defined? Actor::Filter
   Actor::Delegator = Revactor::Delegator unless defined? Actor::Delegator
+  Actor::HttpClient = Revactor::HttpClient unless defined? Actor::HttpClient
 end

data/lib/revactor/actor.rb

@@ -99,6 +99,11 @@ class Actor
       receive { |filter| filter.after(seconds) }
     end
     
+    # Run the event loop and return after processing all outstanding messages
+    def tick
+      sleep 0
+    end
+    
     # Wait for messages matching a given filter.  The filter object is yielded
     # to be block passed to receive.  You can then invoke the when argument
     # which takes a parameter and a block.  Messages are compared (using ===)
@@ -140,7 +145,7 @@ class Actor
         current.instance_eval { @dead = true }
       end
       
-      actor = Actor.new(fiber)
+      actor = new(fiber)
       fiber.instance_eval { @_actor = actor }
     end
   end
@@ -181,7 +186,11 @@ class Actor
   
   # Send a message to an actor
   def <<(message)
-    return "can't send messages to actors across threads" unless @thread == Thread.current
+    # Use the scheduler mailbox to send messages across threads
+    unless @thread == Thread.current
+      scheduler.mailbox.send(self, message)
+      return message
+    end
         
     # Erlang discards messages sent to dead actors, and if Erlang does it,
     # it must be the right thing to do, right?  Hooray for the Erlang 

data/lib/revactor/filters/packet.rb

@@ -14,7 +14,7 @@ module Revactor
     # length prefix followed by a message body, such as DRb.  Either 16-bit
     # or 32-bit prefixes are supported.
     class Packet
-      def initialize(size = 2)
+      def initialize(size = 4)
         unless size == 2 or size == 4
           raise ArgumentError, 'only 2 or 4 byte prefixes are supported' 
         end

data/lib/revactor/http_client.rb

@@ -0,0 +1,349 @@
+#--
+# 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__) + '/../revactor'
+require 'uri'
+
+  
+module Revactor
+  # Thrown for all HTTP-specific errors
+  class HttpClientError < StandardError; end
+  
+  # A high performance HTTP client which wraps the asynchronous client in Rev
+  class HttpClient < Rev::HttpClient
+    # Default timeout for HTTP requests (until the response header is received)
+    REQUEST_TIMEOUT = 60
+    
+    # Read timeout for responses from the server
+    READ_TIMEOUT = 30
+    
+    # Maximum number of HTTP redirects to follow
+    MAX_REDIRECTS = 10
+    
+    # Statuses which indicate the request was redirected
+    REDIRECT_STATUSES = [301, 302, 303, 307]
+    
+    class << self
+      def connect(host, port = 80)        
+        client = super
+        client.instance_eval { @receiver = Actor.current }
+        client.attach Rev::Loop.default
+      
+        Actor.receive do |filter|
+          filter.when(T[Object, client]) do |message, _|
+            case message
+            when :http_connected
+              client.disable
+              return client
+            when :http_connect_failed
+              raise TCP::ConnectError, "connection refused"
+            when :http_resolve_failed
+              raise TCP::ResolveError, "couldn't resolve #{host}"
+            else raise "unexpected message for #{client.inspect}: #{message.inspect}"
+            end              
+          end
+
+          filter.after(TCP::CONNECT_TIMEOUT) do
+            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)
+        follow_redirects = options.has_key?(:follow_redirects) ? options[:follow_redirects] : true
+        uri = URI.parse(uri)
+        
+        MAX_REDIRECTS.times do
+          raise URI::InvalidURIError, "invalid HTTP URI: #{uri}" unless uri.is_a? URI::HTTP
+          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)
+          
+          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
+          end
+          
+          uri = URI.parse(location)
+        end
+        
+        raise HttpClientError, "exceeded maximum of #{MAX_REDIRECTS} redirects"
+      end
+      
+      Rev::HttpClient::ALLOWED_METHODS.each do |meth|
+        module_eval <<-EOD
+          def #{meth}(uri, options = {}, &block)
+            request(:#{meth}, uri, options, &block)
+          end
+        EOD
+      end
+    end
+    
+    def initialize(socket)
+      super
+      @controller = @receiver ||= Actor.current
+    end
+    
+    # Change the controlling Actor for active mode reception
+    # Set the controlling actor
+    def controller=(controller)
+      raise ArgumentError, "controller must be an actor" unless controller.is_a? Actor
+      
+      @receiver = controller if @receiver == @controller
+      @controller = controller
+    end
+    
+    # Initiate an HTTP request for the given path using the given method
+    # Supports the following options:
+    #
+    #   ssl: Boolean
+    #     If true, an HTTPS request will be made
+    #
+    #   head: {Key: Value, Key2: Value2}
+    #     Specify HTTP headers, e.g. {'Connection': 'close'}
+    #
+    #   query: {Key: Value}
+    #     Specify query string parameters (auto-escaped)
+    #
+    #   cookies: {Key: Value}
+    #     Specify hash of cookies (auto-escaped)
+    #
+    #   body: String
+    #     Specify the request body (you must encode it for now)
+    #
+    def request(method, path, options = {})
+      if options[:ssl]
+        ssl_handshake
+        
+        Actor.receive do |filter|
+          filter.when(T[:https_connected, self]) do
+            disable
+          end
+          
+          filter.when(T[:http_closed, self]) do
+            raise EOFError, "SSL handshake failed"
+          end
+          
+          filter.after(TCP::CONNECT_TIMEOUT) do
+            close unless closed?
+            raise TCP::ConnectError, "SSL handshake timed out"
+          end
+        end
+      end
+      
+      super
+      enable
+      
+      Actor.receive do |filter|
+        filter.when(T[:http_response_header, self]) do |_, _, response_header|
+          return HttpResponse.new(self, response_header)
+        end
+        
+        filter.when(T[:http_error, self, Object]) do |_, _, reason|
+          close unless closed?
+          raise HttpClientError, reason
+        end
+        
+        filter.when(T[:http_closed, self]) do
+          raise EOFError, "connection closed unexpectedly"
+        end
+
+        filter.after(REQUEST_TIMEOUT) do
+          @finished = true
+          close unless closed?
+          
+          raise HttpClientError, "request timed out"
+        end
+      end
+    end
+    
+    #########
+    protected
+    #########
+    
+    def ssl_handshake
+      require 'rev/ssl'
+      extend Rev::SSL
+      ssl_client_start
+    end
+    
+    def on_connect
+      super
+      @receiver << T[:http_connected, self]
+    end
+    
+    def on_ssl_connect
+      @receiver << [:https_connected, self]
+    end
+    
+    def on_connect_failed
+      super
+      @receiver << T[:http_connect_failed, self]
+    end
+    
+    def on_resolve_failed
+      super
+      @receiver << T[:http_resolve_failed, self]
+    end
+    
+    def on_response_header(response_header)
+      disable
+      @receiver << T[:http_response_header, self, response_header]
+    end
+    
+    def on_body_data(data)
+      disable if enabled? and not @active 
+      @receiver << T[:http, self, data]
+    end
+    
+    def on_request_complete
+      @finished = true
+      @receiver << T[:http_request_complete, self]
+      close
+    end
+    
+    def on_close
+      @receiver << T[:http_closed, self] unless @finished
+    end
+    
+    def on_error(reason)
+      @finished = true
+      @receiver << T[:http_error, self, reason]
+      close
+    end
+  end
+  
+  # An object representing a response to an HTTP request
+  class HttpResponse
+    def initialize(client, response_header)
+      @client = client
+      
+      # Copy these out of the original Rev response object, then discard it
+      @status = response_header.status
+      @reason = response_header.http_reason
+      @version = response_header.http_version
+      @content_length = response_header.content_length
+      @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 }
+      
+      # Extract Transfer-Encoding if available
+      @transfer_encoding = @headers.delete('transfer-encoding')
+      
+      # Extract Content-Type if available
+      @content_type = @headers.delete('content-type')
+      
+      # Extract Content-Encoding if available
+      @content_encoding = @headers.delete('content-encoding') || 'identity'
+    end
+    
+    # The response status as an integer (e.g. 200)
+    attr_reader :status
+    
+    # The reason returned in the http response (e.g "OK", "File not found", etc.)
+    attr_reader :reason
+    
+    # The HTTP version returned (e.g. "HTTP/1.1")
+    attr_reader :version
+    
+    # The encoding of the transfer
+    attr_reader :transfer_encoding
+    
+    # The encoding of the content.  Gzip encoding will be processed automatically
+    attr_reader :content_encoding
+    
+    # The MIME type of the response's content
+    attr_reader :content_type
+    
+    # The content length as an integer, or nil if the length is unspecified or
+    # the response is using chunked transfer encoding
+    attr_reader :content_length
+    
+    # Access to the raw header fields from the request
+    attr_reader :headers
+    
+    # Is the request encoding chunked?
+    def chunked_encoding?; @chunked_encoding; end
+    
+    # Incrementally read the response body
+    def read_body
+      @client.controller = Actor.current
+      @client.enable if @client.attached? and not @client.enabled?
+      
+      Actor.receive do |filter|
+        filter.when(T[:http, @client]) do |_, _, data|
+          return data
+        end
+        
+        filter.when(T[:http_request_complete, @client]) do
+          return nil
+        end
+        
+        filter.when(T[:http_error, @client]) do |_, _, reason|
+          raise HttpClientError, reason
+        end
+        
+        filter.when(T[:http_closed, @client]) do
+          raise EOFError, "connection closed unexpectedly"
+        end
+
+        filter.after(HttpClient::READ_TIMEOUT) do
+          @finished = true
+          @client.close unless @client.closed?          
+          raise HttpClientError, "read timed out"
+        end
+      end
+    end
+    
+    # Consume the entire response body and return it as a string.
+    # The body is stored for subsequent access.
+    # A maximum body length may optionally be specified
+    def body(maxlength = nil)
+      return @body if @body
+      @body = ""
+      
+      begin
+        while (data = read_body)
+          @body << data
+          
+          if maxlength and @body.size > maxlength
+            raise HttpClientError, "overlength body"
+          end
+        end
+      rescue EOFError => ex
+        # If we didn't get a Content-Length and encoding isn't chunked
+        # we have to depend on the socket closing to detect end-of-body
+        # Otherwise the EOFError was unexpected and should be raised
+        unless (content_length.nil? or content_length.zero?) and not chunked_encoding?
+          raise ex 
+        end
+      end
+      
+      if content_length and body.size != content_length
+        raise HttpClientError, "body size does not match Content-Length (#{body.size} of #{content_length})"
+      end
+      
+      @body
+    end
+    
+    # Explicitly close the connection
+    def close
+      return if @client.closed?
+      @finished = true
+      @client.controller = Actor.current
+      @client.close      
+    end
+  end
+end

data/lib/revactor/mailbox.rb

@@ -30,7 +30,7 @@ class Actor
 
       # Clear mailbox processing variables
       action = matched_index = nil
-      processed_upto = 0
+      at = 0
     
       # Clear timeout variables
       @timed_out = false
@@ -43,19 +43,13 @@ class Actor
 
       # Process incoming messages
       while action.nil?
-        @queue[processed_upto..@queue.size].each_with_index do |message, index|
-          unless (action = filter.match message)
-            # The filter did not match an action for the current message
-            # Keep track of which messages we've ran the filter across so it
-            # isn't re-run against messages it already failed to match
-            processed_upto += 1
-            next
-          end
-        
-          # We've found a matching action, so break out of the loop
-          matched_index = processed_upto + index
+        at.upto(@queue.size - 1) do |i|
+          next unless action = filter.match(@queue[i])
+          matched_index = i
           break
         end
+        
+        at = @queue.size
 
         # Ignore timeouts if we've matched a message
         if action
@@ -91,6 +85,11 @@ class Actor
     def empty?
       @queue.empty?
     end
+    
+    # Clear the mailbox
+    def clear
+      @queue.clear
+    end
   
     #######
     private
@@ -121,7 +120,8 @@ class Actor
       # Provide a pattern to match against with === and a block to call
       # when the pattern is matched.
       def when(pattern, &action)
-        raise ArgumentError, "no block given" unless action
+        # Don't explicitly require an action to be specified 
+        action ||= proc {}
         @ruleset << [pattern, action]
       end
 
@@ -131,7 +131,7 @@ class Actor
         raise ArgumentError, "timeout already specified" if @mailbox.timer
         raise ArgumentError, "must be zero or positive" if seconds < 0
       
-        # Don't explicitly require an action to be specified for a timeout
+        # Don't explicitly require an action to be specified
         @mailbox.timeout_action = action || proc {}
         @mailbox.timer = Timer.new(seconds, Actor.current).attach(Rev::Loop.default)
       end

data/lib/revactor/mongrel.rb

@@ -29,33 +29,41 @@ module Mongrel
       @timeout = timeout
     end
 
-    # Runs the thing.  It returns the Actor the listener is running in.
-    def run
-      @acceptor = Actor.spawn do
-        begin
-          while true
-            begin
-              client = @socket.accept
-              actor = Actor.spawn client, &method(:process_client)
-              actor[:started_on] = Time.now
-            rescue StopServer
-              break
-            rescue Errno::ECONNABORTED
-              # client closed the socket even before accept
-              client.close rescue nil
-            rescue Object => e
-              STDERR.puts "#{Time.now}: Unhandled listen loop exception #{e.inspect}."
-              STDERR.puts e.backtrace.join("\n")
-            end
+    # Start Mongrel.  This method executes the Mongrel event loop, and will
+    # not return until interrupted or explicitly stopped.
+    def start
+      begin
+        while true
+          begin
+            client = @socket.accept
+            actor = Actor.spawn client, &method(:process_client)
+            actor[:started_on] = Time.now
+          rescue Interrupt, StopServer
+            break
+          rescue Errno::ECONNABORTED
+            # client closed the socket even before accept
+            client.close rescue nil
+          rescue Object => e
+            STDERR.puts "#{Time.now}: Unhandled listen loop exception #{e.inspect}."
+            STDERR.puts e.backtrace.join("\n")
           end
-          graceful_shutdown
-        ensure
-          @socket.close
-          # STDERR.puts "#{Time.now}: Closed socket."
         end
+        graceful_shutdown
+      ensure
+        @socket.close
+        # STDERR.puts "#{Time.now}: Closed socket."
       end
+    end
 
-      return @acceptor
+    # Runs the thing.  Returns the Thread the server is running in.
+    def run
+      @acceptor = Thread.new { start }
+    end
+    
+    # Clean up after any dead workers
+    def reap_dead_workers(reason = 'unknown')
+      # FIXME This should signal all workers to die
+      0
     end
   end
 end

data/lib/revactor/scheduler.rb

@@ -4,6 +4,7 @@
 # See file LICENSE for details
 #++
 
+require 'thread'
 require File.dirname(__FILE__) + '/../revactor'
 
 class Actor
@@ -12,9 +13,13 @@ class Actor
   # processed their mailboxes then the scheduler waits for any outstanding
   # Rev events.  If there are no active Rev watchers then the scheduler exits.
   class Scheduler
+    attr_reader :mailbox
+    
     def initialize
       @queue = []
       @running = false
+      @mailbox = Mailbox.new
+      @mailbox.attach Rev::Loop.default
     end
 
     # Schedule an Actor to be executed, and run the scheduler if it isn't
@@ -25,16 +30,21 @@ class Actor
       @queue << actor unless @queue.last == actor
       
       unless @running
-        # Persist the fiber the scheduler runs in
-        @fiber ||= Fiber.new do 
-          loop { run; Fiber.yield }
-        end
-        
-        # Resume the scheduler
-        @fiber.resume
+        # Reschedule the current Actor for execution
+        @queue << Actor.current
+
+        # Start the scheduler
+        Fiber.new { run }.resume
       end
     end
-  
+    
+    # Is the scheduler running?
+    def running?; @running; end
+
+    #########
+    protected
+    #########
+      
     # Run the scheduler
     def run
       return if @running
@@ -42,35 +52,24 @@ class Actor
       @running = true
       default_loop = Rev::Loop.default
     
-      until @queue.empty? and not default_loop.has_active_watchers?
-        @queue.each do |actor|
+      while true
+        while actor = @queue.shift
           begin
             actor.fiber.resume
             handle_exit(actor) if actor.dead?
           rescue FiberError
             # Handle Actors whose Fibers died after being scheduled
+            actor.instance_eval { @dead = true }
             handle_exit(actor)
           rescue => ex
             handle_exit(actor, ex)
           end
         end
       
-        @queue.clear
-        default_loop.run_once if default_loop.has_active_watchers?
+        default_loop.run_once
       end
-    
-      @running = false
-    end
-  
-    # Is the scheduler running?
-    def running?
-      @running
     end
-    
-    #########
-    protected
-    #########
-    
+
     def handle_exit(actor, ex = nil)
       actor.instance_eval do
         # Mark Actor as dead
@@ -92,5 +91,33 @@ class Actor
       # FIXME this should go to a real logger
       STDERR.puts "#{ex.class}: #{[ex, *ex.backtrace].join("\n\t")}"
     end
+    
+    # The Scheduler Mailbox allows messages to be safely delivered across
+    # threads.  If a thread is sleeping sending it a message will wake
+    # it up.
+    class Mailbox < Rev::AsyncWatcher
+      def initialize
+        super
+        
+        @queue = []
+        @lock = Mutex.new
+      end
+      
+      def send(actor, message)
+        @lock.synchronize { @queue << T[actor, message] }
+        signal
+      end
+            
+      #########
+      protected
+      #########
+      
+      def on_signal
+        @lock.synchronize do
+          @queue.each { |actor, message| actor << message }
+          @queue.clear
+        end
+      end
+    end
   end
 end

data/lib/revactor/tcp.rb

@@ -31,7 +31,7 @@ module Revactor
       socket.attach Rev::Loop.default
 
       Actor.receive do |filter|
-        filter.when(Case[Object, socket]) do |message, _|
+        filter.when(T[Object, socket]) do |message, _|
           case message
           when :tcp_connected
             return socket
@@ -56,6 +56,11 @@ module Revactor
     #
     #   :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::TCP::Socket.
+    #             See the "Filters" section in the README for more information
+    #
     def self.listen(addr, port, options = {})
       Listener.new(addr, port, options).attach(Rev::Loop.default).disable
     end
@@ -77,12 +82,13 @@ module Revactor
         #   :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::TCP::Socket.
+        #             See the "Filters" section in the README for more information
         #
         def connect(host, port, options = {})
           options[:active]     ||= false
           options[:controller] ||= Actor.current
         
-          super(host, port, options).instance_eval {
+          super.instance_eval {
             @active, @controller = options[:active], options[:controller]
             @filterset = initialize_filter(*options[:filter])
             self
@@ -112,6 +118,7 @@ module Revactor
       #   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" 
@@ -162,7 +169,7 @@ module Revactor
         
         loop do
           Actor.receive do |filter|
-            filter.when(Case[:tcp, self, Object]) do |_, _, data|
+            filter.when(T[:tcp, self]) do |_, _, data|
               if length.nil?
                 @receiver = @controller
                 @active = active
@@ -182,7 +189,7 @@ module Revactor
               end
             end
             
-            filter.when(Case[:tcp_closed, self]) do
+            filter.when(T[:tcp_closed, self]) do
               unless @receiver == @controller
                 @receiver = @controller
                 @receiver << T[:tcp_closed, self]
@@ -207,19 +214,16 @@ module Revactor
         super(encode(data))
         
         Actor.receive do |filter|
-          filter.when(Case[:tcp_write_complete, self]) do
+          filter.when(T[:tcp_write_complete, self]) do
             @receiver = @controller
             @active = active
-            enable if @active
+            enable if @active and not enabled?
             
             return data.size
           end
           
-          filter.when(Case[:tcp_closed, self]) do
-            @receiver = @controller
-            @active = active
-            enable if @active
-            
+          filter.when(T[:tcp_closed, self]) do
+            @active = false
             raise EOFError, "connection closed"
           end
         end
@@ -307,7 +311,7 @@ module Revactor
         
         if message.is_a?(Array) and not message.empty?
           message.each { |msg| @receiver << T[:tcp, self, msg] }
-        elsif message
+        elsif message and not message.empty?
           @receiver << T[:tcp, self, message]
         else return
         end
@@ -334,6 +338,11 @@ module Revactor
       #
       #   :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::TCP::Socket.
+      #             See the "Filters" section in the README for more information
+      #
       def initialize(host, port, options = {})
         super(host, port)
         opts = {
@@ -378,7 +387,7 @@ module Revactor
         enable
         
         Actor.receive do |filter|
-          filter.when(Case[:tcp_connection, self, Object]) do |_, _, sock|
+          filter.when(T[:tcp_connection, self]) do |_, _, sock|
             @accepting = false            
             return sock
           end

data/revactor.gemspec

@@ -2,10 +2,10 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "revactor"
-  s.version = "0.1.2"
+  s.version = "0.1.3"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2008-1-28"
+  s.date = "2008-1-29"
   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,8 +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.1.4")
-  s.add_dependency("case", ">= 0.4")
+  s.add_dependency("rev", ">= 0.2.0")
 
   # RubyForge info
   s.homepage = "http://revactor.org"

data/spec/actor_spec.rb

@@ -44,6 +44,9 @@ describe Actor do
       end
       
       actor << :foo
+      
+      # Hack to run the Actor scheduler once
+      Actor.sleep 0
       @actor_run.should be_true
     end
     
@@ -62,6 +65,9 @@ describe Actor do
       end
       
       ['first message', 'second message', 'third message'].each { |m| actor << m }
+      
+      # Hack to run the Actor scheduler once
+      Actor.sleep 0
       @actor_run.should be_true
     end
         
@@ -73,6 +79,9 @@ describe Actor do
         end.should == :right
         @actor_run = true
       end
+      
+      # Hack to run the Actor scheduler
+      Actor.sleep 0.02
       @actor_run.should be_true
     end
     
@@ -90,6 +99,9 @@ describe Actor do
       end
       
       [:foo, :bar, :baz].each { |m| actor << m }
+      
+      # Hack to run the Actor scheduler once
+      Actor.sleep 0
       @actor_run.should be_true
     end
   end
@@ -139,6 +151,9 @@ describe Actor do
     
     actor.dead?.should be_false
     actor << :foobar
+    
+    # Hack to run the Actor scheduler once
+    Actor.sleep 0
     actor.dead?.should be_true
   end
 end

metadata

@@ -1,33 +1,36 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: revactor
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2008-01-28 00:00:00 -07:00
-summary: Revactor is an Actor implementation for writing high performance concurrent programs
-require_paths: 
-- lib
-email: tony@medioh.com
-homepage: http://revactor.org
-rubyforge_project: revactor
-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: 
+  version: 0.1.3
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Tony Arcieri
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-29 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rev
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+description: 
+email: tony@medioh.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- CHANGES
 files: 
 - lib/revactor
 - lib/revactor/actor.rb
@@ -35,15 +38,16 @@ files:
 - lib/revactor/filters
 - lib/revactor/filters/line.rb
 - lib/revactor/filters/packet.rb
+- lib/revactor/http_client.rb
 - lib/revactor/mailbox.rb
 - lib/revactor/mongrel.rb
 - lib/revactor/scheduler.rb
 - lib/revactor/tcp.rb
 - lib/revactor.rb
+- examples/chat_server.rb
 - examples/echo_server.rb
 - examples/google.rb
 - examples/mongrel.rb
-- tools/messaging_throughput.rb
 - spec/actor_spec.rb
 - spec/delegator_spec.rb
 - spec/line_filter_spec.rb
@@ -54,40 +58,35 @@ files:
 - LICENSE
 - README
 - CHANGES
-test_files: []
-
+has_rdoc: true
+homepage: http://revactor.org
+post_install_message: 
 rdoc_options: 
 - --title
 - Revactor
 - --main
 - README
 - --line-numbers
-extra_rdoc_files: 
-- LICENSE
-- README
-- CHANGES
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rev
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.1.4
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: case
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0.4"
-    version: 
+rubyforge_project: revactor
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Revactor is an Actor implementation for writing high performance concurrent programs
+test_files: []
+

data/tools/messaging_throughput.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/revactor'
-
-NTIMES=100000
-
-begin_time = Time.now
-
-puts "#{begin_time.strftime('%H:%M:%S')} -- Sending #{NTIMES} messages"
-
-parent = Actor.current
-child = Actor.spawn do
-  (NTIMES / 2).times do
-    Actor.receive do |f|
-      f.when(:foo) { parent << :bar }
-    end
-  end
-end
-
-child << :foo
-(NTIMES / 2).times do
-  Actor.receive do |f|
-    f.when(:bar) { child << :foo }
-  end
-end
-
-end_time = Time.now
-duration = end_time - begin_time
-throughput = NTIMES / duration
-
-puts "#{end_time.strftime('%H:%M:%S')} -- Finished"
-puts "Duration:   #{sprintf("%0.2f", duration)} seconds"
-puts "Throughput: #{sprintf("%0.2f", throughput)} messages per second"