revactor 0.1.0 → 0.1.1

data/spec/delegator_spec.rb

@@ -0,0 +1,46 @@
+#--
+# 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

data/spec/tcp_spec.rb

@@ -22,63 +22,43 @@ describe Revactor::TCP do
   end
   
   it "connects to remote servers" do
-    Actor.start do
-      sock = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
-      sock.should be_an_instance_of(Revactor::TCP::Socket)
-      @server.accept.should be_an_instance_of(TCPSocket)
-      
-      sock.close
-      @actor_run = true
-    end
+    sock = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+    sock.should be_an_instance_of(Revactor::TCP::Socket)
+    @server.accept.should be_an_instance_of(TCPSocket)
     
-    @actor_run.should be_true
+    sock.close
   end
   
   it "listens for remote connections" do
-    @server.close # Don't use it for this one...
+    @server.close # Don't use their server for this one...
     
-    Actor.start do
-      server = Revactor::TCP.listen(TEST_HOST, RANDOM_PORT)
-      server.should be_an_instance_of(Revactor::TCP::Listener)
-      
-      s1 = TCPSocket.open(TEST_HOST, RANDOM_PORT)
-      s2 = server.accept
-      
-      server.close
-      s2.close
-      @actor_run = true
-    end
+    server = Revactor::TCP.listen(TEST_HOST, RANDOM_PORT)
+    server.should be_an_instance_of(Revactor::TCP::Listener)
     
-    @actor_run.should be_true
+    s1 = TCPSocket.open(TEST_HOST, RANDOM_PORT)
+    s2 = server.accept
+    
+    server.close
+    s2.close
   end
   
   it "reads data" do
-    Actor.start do
-      s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
-      s2 = @server.accept
-    
-      s2.write 'foobar'
-      s1.read(6).should == 'foobar'
-    
-      s1.close
-      @actor_run = true
-    end
+    s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+    s2 = @server.accept
   
-    @actor_run.should be_true
+    s2.write 'foobar'
+    s1.read(6).should == 'foobar'
+  
+    s1.close
   end
 
   it "writes data" do
-    Actor.start do
-      s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
-      s2 = @server.accept
-      
-      s1.write 'foobar'
-      s2.read(6).should == 'foobar'
-      
-      s1.close
-      @actor_run = true
-    end
+    s1 = Revactor::TCP.connect(TEST_HOST, RANDOM_PORT)
+    s2 = @server.accept
+    
+    s1.write 'foobar'
+    s2.read(6).should == 'foobar'
     
-    @actor_run.should be_true  
+    s1.close
   end
 end

data/tools/messaging_throughput.rb

@@ -6,24 +6,22 @@ begin_time = Time.now
 
 puts "#{begin_time.strftime('%H:%M:%S')} -- Sending #{NTIMES} messages"
 
-Actor.start do
-  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
+parent = Actor.current
+child = Actor.spawn do
   (NTIMES / 2).times do
     Actor.receive do |f|
-      f.when(:bar) { child << :foo }
+      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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: revactor
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2008-01-15 00:00:00 -07:00
+  version: 0.1.1
+date: 2008-01-28 00:00:00 -07:00
 summary: Revactor is an Actor implementation for writing high performance concurrent programs
 require_paths: 
 - lib
@@ -31,13 +31,13 @@ authors:
 files: 
 - lib/revactor
 - lib/revactor/actor.rb
-- lib/revactor/behaviors
-- lib/revactor/behaviors/server.rb
+- lib/revactor/delegator.rb
 - lib/revactor/filters
 - lib/revactor/filters/line.rb
 - lib/revactor/filters/packet.rb
+- lib/revactor/mailbox.rb
 - lib/revactor/mongrel.rb
-- lib/revactor/server.rb
+- lib/revactor/scheduler.rb
 - lib/revactor/tcp.rb
 - lib/revactor.rb
 - examples/echo_server.rb
@@ -45,6 +45,7 @@ files:
 - examples/mongrel.rb
 - tools/messaging_throughput.rb
 - spec/actor_spec.rb
+- spec/delegator_spec.rb
 - spec/line_filter_spec.rb
 - spec/packet_filter_spec.rb
 - spec/tcp_spec.rb
@@ -79,7 +80,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.1.3
+        version: 0.1.4
     version: 
 - !ruby/object:Gem::Dependency 
   name: case
@@ -88,5 +89,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0.3"
+        version: "0.4"
     version: 

data/lib/revactor/behaviors/server.rb

@@ -1,87 +0,0 @@
-#--
-# Copyright (C)2007 Tony Arcieri
-# You can redistribute this under the terms of the Ruby license
-# See file LICENSE for details
-#++
-
-module Revactor
-  module Behavior
-    # The Server behavior provides a callback-driven class which eases the
-    # creation of standard synchronous "blocking" calls by abstracting away 
-    # inter-Actor communication and also providing baked-in state management.
-    #
-    # This behavior module provides the base set of callbacks necessary
-    # to implement the behavior.  It also provides descriptions for what
-    # certain callback methods should do.
-    #
-    # When used properly, the server behavior can implement transactional
-    # semantics, ensuring only successful calls mutate the previous state
-    # and erroneous/exception-raising ones do not.
-    #
-    # The design is modeled off Erlang/OTP's gen_server
-    module Server
-      # Initialize the server state.  Can return:
-      #
-      #   start(*args) 
-      #     -> [:ok, state]
-      #     -> [:ok, state, timeout]
-      #     -> [:stop, reason]
-      #
-      # The state variable allows you to provide a set of state whose mutation
-      # can be controlled a lot more closely than is possible with standard
-      # object oriented behavior.  The latest version of state is passed
-      # to all Revactor::Server callbacks and is only mutated upon a
-      # successful return (unless an exception was raised)
-      #
-      def start(*args)
-        return :ok
-      end
-
-      # Handle any calls made to a Reactor::Server object, which are captured
-      # via method_missing and dispatched here.  Calls provide synchronous
-      # behavior: the callee will block until this method completss and a
-      # reply is sent back to them.  Can return:
-      #
-      #   handle_call(message, from, state)
-      #     -> [:reply, reply, new_state]
-      #     -> [:reply, reply, new_state, timeout]
-      #     -> [:noreply, new_state]
-      #     -> [:noreply, new_state, timeout]
-      #     -> [:stop, reason, reply, new_state]
-      #
-      def handle_call(message, from, state)
-        return :reply, :ok, state
-      end
-
-      # Handle calls without return values
-      #
-      #   handle_cast(message, state)
-      #     -> [:noreply, new_state]
-      #     -> [:noreply, new_state, timeout]
-      #     -> [:stop, reason, new_state]
-      #
-      def handle_cast(message, state)
-        return :noreply, state
-      end
-
-      # Handle any spontaneous messages to the server which are not calls
-      # or casts made from Rev::Server.  Can return:
-      #
-      #   handle_info(info, state)
-      #     -> [:noreply, new_state]
-      #     -> [:noreply, new_state, timeout]
-      #     -> [:stop, reason, new_state]
-      #
-      def handle_info(info, state)
-        return :noreply, state
-      end
-
-      # Method called when the server is about to terminate, for example when 
-      # any of the handle_* routines above return :stop.  The return value of
-      # terminate is discarded.
-      #
-      def terminate(reason, state)
-      end
-    end
-  end
-end

data/lib/revactor/server.rb

@@ -1,153 +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__) + '/../revactor'
-
-module Revactor
-  # Revactor::Server wraps an Actor's receive loop and issues callbacks to
-  # a class which implements Revactor::Behaviors::Server.  It eases the
-  # creation of standard synchronous "blocking" calls by abstracting away 
-  # inter-Actor communication and also providing baked-in state management.
-  #
-  # When used properly, Revactor::Server can implement transactional
-  # semantics, ensuring only successful calls mutate the previous state
-  # and erroneous/exception-raising ones do not.
-  #
-  # The design is modeled off Erlang/OTP's gen_server
-  class Server
-    # How long to wait for a response to a call before timing out
-    # This value also borrowed from Erlang.  More cargo culting!
-    DEFAULT_CALL_TIMEOUT = 5
-    
-    # Create a new server.  Accepts the following options:
-    #
-    #   register: Register the Actor in the Actor registry under
-    #             the given term
-    #
-    # Any options passed after the options hash are passed to the
-    # start method of the given object.
-    #
-    def initialize(obj, options = {}, *args)
-      @obj = obj
-      @timeout = nil
-      @state = obj.start(*args)
-      @actor = Actor.new(&method(:start).to_proc)
-      
-      Actor[options[:register]] = @actor if options[:register]
-    end
-    
-    # Call the server with the given message
-    def call(message, options = {})
-      options[:timeout] ||= DEFAULT_CALL_TIMEOUT
-      
-      @actor << T[:call, Actor.current, message]
-      Actor.receive do |filter|
-        filter.when(Case[:call_reply, @actor, Object]) { |_, _, reply| reply }
-        filter.when(Case[:call_error, @actor, Object]) { |_, _, ex| raise ex }
-        filter.after(options[:timeout]) { raise 'timeout' }
-      end
-    end
-    
-    # Send a cast to the server
-    def cast(message)
-      @actor << T[:cast, message]
-      message
-    end
-    
-    #########
-    protected
-    #########
-    
-    # Start the server
-    def start
-      @running = true
-      while @running do
-        Actor.receive do |filter|
-          filter.when(Object) { |message| handle_message(message) }
-          filter.after(@timeout) { stop(:timeout) } if @timeout
-        end
-      end
-    end
-    
-    # Dispatch the incoming message to the appropriate handler
-    def handle_message(message)
-      case message.first
-      when :call then handle_call(message)
-      when :cast then handle_cast(message)
-      else handle_info(message)
-      end
-    end
-    
-    # Wrapper for calling the provided object's handle_call method
-    def handle_call(message)
-      _, from, body = message
-      
-      begin
-        result = @obj.handle_call(body, from, @state)
-        case result.first
-        when :reply
-          _, reply, @state, @timeout = result
-          from << T[:call_reply, Actor.current, reply]
-        when :noreply
-          _, @state, @timeout = result
-        when :stop
-          _, reason, @state = result
-          stop(reason)
-        end
-      rescue Exception => ex
-        log_exception(ex)
-        from << T[:call_error, Actor.current, ex]
-      end
-    end
-    
-    # Wrapper for calling the provided object's handle_cast method
-    def handle_cast(message)
-      _, body = message
-    
-      begin
-        result = @obj.handle_cast(body, @state)
-        case result.first
-        when :noreply
-          _, @state, @timeout = result
-        when :stop
-          _, reason, @state = result
-          stop(reason)
-        end
-      rescue Exception => e
-        log_exception(e)
-      end
-    end
-    
-    # Wrapper for calling the provided object's handle_info method
-    def handle_info(message)
-      begin
-        result = @obj.handle_info(message, @state)
-        case result.first
-        when :noreply
-          _, @state, @timeout = result
-        when :stop
-          _, reason, @state = result
-          stop(reason)
-        end
-      rescue Exception => e
-        log_exception(e)
-      end
-    end
-    
-    # Stop the server
-    def stop(reason)
-      @running = false
-      @obj.terminate(reason, @state)
-    end
-    
-    # Log an exception
-    def log_exception(exception)
-      # FIXME this should really go to a logger, not STDERR
-      STDERR.puts "Rev::Server exception: #{exception}"
-      STDERR.puts exception.backtrace
-    end
-  end
-end