revactor 0.1.0 → 0.1.1

data/lib/revactor/delegator.rb

@@ -0,0 +1,70 @@
+#--
+# 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'
+
+# A Delegator whose delegate runs in a separate Actor.  This allows
+# an easy method for constructing synchronous calls to a separate Actor
+# which cause the current Actor to block until they complete.
+class Revactor::Delegator  
+  # Create a new delegator for the given object
+  def initialize(obj)
+    @obj = obj
+    @running = true
+    @actor = Actor.spawn(&method(:start))
+  end
+  
+  # Stop the delegator Actor
+  def stop
+    @actor << :stop
+    nil
+  end
+  
+  # Send a message to the Actor delegate
+  def send(meth, *args, &block)
+    @actor << T[:call, Actor.current, meth, args, block]
+    Actor.receive do |filter|
+      filter.when(Case[:call_reply, @actor, Object]) { |_, _, reply| reply }
+      filter.when(Case[:call_error, @actor, Object]) { |_, _, ex| raise ex }
+    end
+  end
+  
+  alias_method :method_missing, :send
+  
+  #########
+  protected
+  #########
+  
+  # Start the server
+  def start
+    loop do
+      Actor.receive do |filter|
+        filter.when(:stop)  { |_| return }
+        filter.when(Object) { |message| handle_message(message) }
+      end
+    end
+  end
+  
+  # Dispatch the incoming message to the appropriate handler
+  def handle_message(message)
+    case message.first
+    when :call then handle_call(message)
+    else @obj.__send__(:on_message, message) if @obj.respond_to? :on_message
+    end
+  end
+  
+  # Wrapper for calling the provided object's handle_call method
+  def handle_call(message)
+    _, from, meth, args, block = message
+    
+    begin
+      result = @obj.__send__(meth, *args, &block)
+      from << T[:call_reply, Actor.current, result]
+    rescue Exception => ex
+      from << T[:call_error, Actor.current, ex]
+    end
+  end
+end

data/lib/revactor/mailbox.rb

@@ -0,0 +1,159 @@
+#--
+# 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'
+
+class Actor
+  # Actor mailbox.  For purposes of efficiency the mailbox also handles 
+  # suspending and resuming an actor when no messages match its filter set.
+  class Mailbox
+    attr_accessor :timer
+    attr_accessor :timed_out
+    attr_accessor :timeout_action
+
+    def initialize
+      @timer = nil
+      @queue = []
+    end
+
+    # Add a message to the mailbox queue
+    def <<(message)
+      @queue << message
+    end
+
+    # Attempt to receive a message
+    def receive
+      raise ArgumentError, "no filter block given" unless block_given?
+
+      # Clear mailbox processing variables
+      action = matched_index = nil
+      processed_upto = 0
+    
+      # Clear timeout variables
+      @timed_out = false
+      @timeout_action = nil
+    
+      # Build the filter
+      filter = Filter.new(self)
+      yield filter
+      raise ArgumentError, "empty filter" if filter.empty?
+
+      # 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
+          break
+        end
+
+        # Ignore timeouts if we've matched a message
+        if action
+          @timed_out = false
+          break
+        end
+        
+        # Otherwise run the timeout action
+        action = @timeout_action if @timed_out
+
+        # If no matching action is found, reschedule until we get another message
+        Actor.reschedule unless action
+      end
+
+      @timeout_action = nil
+      
+      if @timer
+        @timer.detach if @timer.attached?
+        @timer = nil
+      end
+    
+      # If we encountered a timeout, call the action directly
+      if @timed_out
+        @timed_out = false
+        return action.call
+      end
+    
+      # Otherwise we matched a message, so process it with the action      
+      action.(@queue.delete_at matched_index)
+    end
+    
+    # Is the mailbox empty?
+    def empty?
+      @queue.empty?
+    end
+  
+    #######
+    private
+    #######
+  
+    # Timeout class, used to implement receive timeouts
+    class Timer < Rev::TimerWatcher
+      def initialize(seconds, actor)
+        @actor = actor
+        super(seconds)
+      end
+
+      def on_timer
+        detach
+        @actor.mailbox.timed_out = true
+        @actor.scheduler << @actor
+      end
+    end
+
+    # Mailbox filterset.  Takes patterns or procs to match messages with
+    # and returns the associated proc when a pattern matches.
+    class Filter
+      def initialize(mailbox)
+        @mailbox = mailbox
+        @ruleset = []
+      end
+
+      # 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
+        @ruleset << [pattern, action]
+      end
+
+      # Provide a timeout (in seconds, can be a Float) to wait for matching
+      # messages.  If the timeout elapses, the given block is called.
+      def after(seconds, &action)
+        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
+        @mailbox.timeout_action = action || proc {}
+      
+        if seconds > 0
+          @mailbox.timer = Timer.new(seconds, Actor.current).attach(Rev::Loop.default)
+        else
+          # No need to actually set a timer if the timeout is zero, 
+          # just short-circuit waiting for one entirely...
+          @mailbox.timed_out = true
+          Actor.scheduler << Actor.current
+        end
+      end
+
+      # Match a message using the filter
+      def match(message)
+        _, action = @ruleset.find { |pattern, _| pattern === message }
+        action
+      end
+
+      # Is the filterset empty?
+      def empty?
+        @ruleset.empty? and not @mailbox.timer
+      end
+    end
+  end
+end

data/lib/revactor/mongrel.rb

@@ -32,12 +32,12 @@ module Mongrel
 
     # Runs the thing.  It returns the Actor the listener is running in.
     def run
-      @acceptor = Actor.new do
+      @acceptor = Actor.spawn do
         begin
           while true
             begin
               client = @socket.accept
-              actor = Actor.new client, &method(:process_client)
+              actor = Actor.spawn client, &method(:process_client)
               actor[:started_on] = Time.now
             rescue StopServer
               break
@@ -59,4 +59,4 @@ module Mongrel
       return @acceptor
     end
   end
-end
+end

data/lib/revactor/scheduler.rb

@@ -0,0 +1,65 @@
+#--
+# 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'
+
+class Actor
+  # The Actor Scheduler maintains a run queue of actors with outstanding
+  # messages who have not yet processed their mailbox.  If all actors have
+  # 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
+    def initialize
+      @queue = []
+      @running = false
+    end
+
+    # Schedule an Actor to be executed, and run the scheduler if it isn't
+    # currently running
+    def <<(actor)
+      raise ArgumentError, "must be an Actor" unless actor.is_a? 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
+      end
+    end
+  
+    # Run the scheduler
+    def run
+      return if @running
+    
+      @running = true
+      default_loop = Rev::Loop.default
+    
+      until @queue.empty? and not default_loop.has_active_watchers?
+        @queue.each do |actor|
+          begin
+            actor.fiber.resume
+          rescue FiberError # Fiber may have died since being scheduled 
+          end
+        end
+      
+        @queue.clear
+        default_loop.run_once if default_loop.has_active_watchers?
+      end
+    
+      @running = false
+    end
+  
+    # Is the scheduler running?
+    def running?
+      @running
+    end
+  end
+end

data/lib/revactor/tcp.rb

@@ -31,15 +31,15 @@ module Revactor
       socket.attach Rev::Loop.default
 
       Actor.receive do |filter|
-        filter.when(Case[Object, socket]) do |message|
-          case message[0]
+        filter.when(Case[Object, socket]) do |message, _|
+          case message
           when :tcp_connected
             return socket
           when :tcp_connect_failed
             raise ConnectError, "connection refused"
           when :tcp_resolve_failed
             raise ResolveError, "couldn't resolve #{host}"
-          else raise "unexpected message for #{socket.inspect}: #{message.first}"
+          else raise "unexpected message for #{socket.inspect}: #{message}"
           end              
         end
 
@@ -102,6 +102,10 @@ module Revactor
         @read_buffer = Rev::Buffer.new
       end
       
+      def inspect
+        "#<#{self.class}:0x#{object_id.to_s(16)} #{@remote_host}:#{@remote_port}>"
+      end
+      
       # Enable or disable active mode data reception.  State can be any
       # of the following:
       #
@@ -255,8 +259,8 @@ module Revactor
       # Lookup filters referenced as symbols
       def symbol_to_filter(filter)
         case filter
-        when :line then Revactor::Filters::Line
-        when :packet then Revactor::Filters::Packet
+        when :line then Revactor::Filter::Line
+        when :packet then Revactor::Filter::Packet
         else raise ArgumentError, "unrecognized filter type: #{filter}"
         end
       end
@@ -342,6 +346,10 @@ module Revactor
         @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

data/revactor.gemspec

@@ -2,10 +2,10 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "revactor"
-  s.version = "0.1.0"
+  s.version = "0.1.1"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2008-1-15"
+  s.date = "2008-1-28"
   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,8 @@ GEMSPEC = Gem::Specification.new do |s|
   s.files = Dir.glob("{lib,examples,tools,spec}/**/*") + ['Rakefile', 'revactor.gemspec']
 
   # Dependencies
-  s.add_dependency("rev", ">= 0.1.3")
-  s.add_dependency("case", ">= 0.3")
+  s.add_dependency("rev", ">= 0.1.4")
+  s.add_dependency("case", ">= 0.4")
 
   # RubyForge info
   s.homepage = "http://revactor.org"

data/spec/actor_spec.rb

@@ -8,52 +8,33 @@ require File.dirname(__FILE__) + '/../lib/revactor/actor'
 
 describe Actor do
   describe "creation" do
-    it "creates a base Actor with Actor.start" do
-      Actor.start do
-        Fiber.current.should be_an_instance_of(Actor)
-      end
-    end
-  
-    it "allows creation of new Actors with Actor.new" do
-      Actor.new do
-        Fiber.current.should be_an_instance_of(Actor)
-      end
+    it "lazily creates Actor.current" do
+      Actor.current.should be_an_instance_of(Actor)
     end
     
     it "allows creation of new Actors with Actor.spawn" do
+      root = Actor.current
+      
       Actor.spawn do
-        Fiber.current.should be_an_instance_of(Actor)
+        Actor.current.should be_an_instance_of(Actor)
+        Actor.current.should_not eql(root)
       end
     end
     
     it "allows arguments to be passed when an Actor is created" do
-      [:new, :spawn].each do |meth|
-        Actor.send(meth, 1, 2, 3) do |foo, bar, baz|
-          [foo, bar, baz].should == [1, 2, 3]
-        end
+      Actor.spawn(1, 2, 3) do |foo, bar, baz|
+        [foo, bar, baz].should == [1, 2, 3]
       end
     end
   end
   
-  describe "current" do
-    it "allows the current Actor to be retrieved" do
-      Actor.new do
-        Actor.current.should be_an_instance_of(Actor)
-      end
-    end
-  
-    it "disallows retrieving the current Actor unless the Actor environment is started" do
-      proc { Actor.current }.should raise_error(ActorError)
-    end
-  end
-  
   describe "receive" do
     before :each do
       @actor_run = false
     end
     
     it "returns the value of the matching filter action" do
-      actor = Actor.new do
+      actor = Actor.spawn do
         Actor.receive do |filter|
           filter.when(:foo) { |message| :bar }
         end.should == :bar
@@ -67,7 +48,7 @@ describe Actor do
     end
     
     it "filters messages with ===" do
-      actor = Actor.new do
+      actor = Actor.spawn do
         results = []
         3.times do
           results << Actor.receive do |filter|
@@ -85,7 +66,7 @@ describe Actor do
     end
         
     it "times out if a message isn't received after the specifed interval" do
-      actor = Actor.new do
+      actor = Actor.spawn do
         Actor.receive do |filter|
           filter.when(:foo) { :wrong }
           filter.after(0.01) { :right }
@@ -96,7 +77,7 @@ describe Actor do
     end
     
     it "matches any message with Object" do
-      actor = Actor.new do
+      actor = Actor.spawn do
         result = []
         3.times do
           result << Actor.receive do |filter|
@@ -114,7 +95,7 @@ describe Actor do
   end
   
   it "detects dead actors" do
-    actor = Actor.new do
+    actor = Actor.spawn do
       Actor.receive do |filter|
         filter.when(Object) {}
       end