thespian 0.0.1 → 0.1.0

data/lib/thespian/strategies/fiber.rb

@@ -0,0 +1,52 @@
+begin
+  require "fiber"
+rescue LoadError
+  raise "Thespian requires Ruby >= 1.9 to run in fibered mode"
+end
+
+require "strand"
+
+module Thespian
+  module Strategy
+    class Fiber #:nodoc:
+
+      include Interface
+
+      def initialize(&block)
+        @block        = block
+        @mailbox      = []
+        @mailbox_cond = Strand::ConditionVariable.new
+      end
+
+      def start
+        @strand = Strand.new{ @block.call }
+        self
+      end
+
+      def receive
+        @mailbox_cond.wait while @mailbox.empty?
+        @mailbox.shift
+      end
+
+      def <<(message)
+        @mailbox << message
+        @mailbox_cond.signal
+        self
+      end
+
+      def mailbox_size
+        @mailbox.size
+      end
+
+      def messages
+        @mailbox.dup
+      end
+
+      def stop
+        self << Stop.new
+        @strand.join
+      end
+
+    end
+  end
+end

data/lib/thespian/strategies/interface.rb

@@ -0,0 +1,35 @@
+module Thespian
+  module Strategy #:nodoc:
+
+    autoload :Thread, "thespian/strategies/thread"
+    autoload :Fiber,  "thespian/strategies/fiber"
+
+    module Interface #:nodoc:
+
+      def start
+        raise "not implemented"
+      end
+
+      def receive
+        raise "not implemented"
+      end
+
+      def <<(message)
+        raise "not implemented"
+      end
+
+      def mailbox_size
+        raise "not implemented"
+      end
+
+      def stop
+        raise "not implemented"
+      end
+
+      def salvage_mailbox
+        raise "not implemented"
+      end
+
+    end
+  end
+end

data/lib/thespian/strategies/process.rb

@@ -0,0 +1,73 @@
+require "thread"
+require "monitor"
+require "json"
+
+module Thespian
+  module Strategy
+    class Process #:nodoc:
+
+      include Interface
+
+      def initialize(&block)
+        @block        = block
+        @mailbox      = []
+        @mailbox_lock = Monitor.new
+        @mailbox_cond = @mailbox_lock.new_cond
+        @p_read, @p_write = IO.pipe
+        @c_read, @c_write = IO.pipe
+      end
+
+      def start
+        if fork
+          self
+        else
+          ::Thread.new{ puts "in thread"; command_loop }
+          puts "calling block"
+          @block.call
+        end
+      end
+
+      def receive
+        @mailbox_lock.synchronize do
+          @mailbox_cond.wait_while{ @mailbox.empty? }
+          @mailbox.shift
+        end
+      end
+
+      def <<(message)
+        @c_write.puts(JSON.dump({ "cmd" => "message", "payload" => Marshal.dump(message) }))
+        @c_write.flush
+        puts "written"
+      end
+
+      def mailbox_size
+        @c_write.puts(JSON.dump({ "cmd" => "mailbox_size" }))
+        @c_write.flush
+        @p_read.readline.chomp.to_i
+      end
+
+      def command_loop
+        puts "in command loop"
+        while line = @c_read.readline
+          puts "!!! #{line}"
+          hash = JSON.parse(line)
+          send("cmd_%s" % hash["cmd"], hash)
+        end
+      end
+
+      def cmd_message(hash)
+        message = Marshal.load(hash["payload"])
+        @mailbox_lock.synchronize do
+          @mailbox << message
+          @mailbox_cond.signal
+        end
+      end
+
+      def cmd_mailbox_size(hash)
+        @p_write.puts(@mailbox.size)
+        @p_write.flush
+      end
+
+    end
+  end
+end

data/lib/thespian/strategies/thread.rb

@@ -0,0 +1,74 @@
+require "thread"
+require "monitor"
+
+module Thespian
+  module Strategy
+    class Thread #:nodoc:
+
+      include Interface
+
+      attr_reader :thread
+
+      def initialize(&block)
+        @block        = block
+        @mailbox      = []
+        @mailbox_lock = Monitor.new
+        @mailbox_cond = @mailbox_lock.new_cond
+      end
+
+      def start
+        # Declare local synchronization vars.
+        lock = Monitor.new
+        cond = lock.new_cond
+        wait = true
+
+         # Start the thread and have it signal when it's running.
+        @thread = ::Thread.new do
+          lock.synchronize do
+            wait = false
+            cond.signal
+          end
+          @block.call
+        end
+
+        # Block until the thread has signaled that it's running.
+        lock.synchronize do
+          cond.wait_while{ wait }
+        end
+      end
+
+      def receive
+        @mailbox_lock.synchronize do
+          @mailbox_cond.wait_while{ @mailbox.empty? }
+          @mailbox.shift
+        end
+      end
+
+      def <<(message)
+        @mailbox_lock.synchronize do
+          @mailbox << message
+          @mailbox_cond.signal
+        end
+        self
+      end
+
+      def mailbox_size
+        @mailbox_lock.synchronize do
+          @mailbox.size
+        end
+      end
+
+      def messages
+        @mailbox_lock.synchronize do
+          @mailbox.dup
+        end
+      end
+
+      def stop
+        self << Stop.new
+        @thread.join
+      end
+
+    end
+  end
+end

data/lib/thespian/version.rb

@@ -1,3 +1,3 @@
 module Thespian
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/actor_spec.rb

@@ -3,8 +3,9 @@ require "spec_helper"
 module Thespian
   describe Actor do
 
+    let(:actor){ Actor.new.extend(ActorHelper) }
+
     context "#new" do
-      let(:actor){ Actor.new }
 
       it "returns a new Actor" do
         actor.should be_a(Actor)
@@ -13,6 +14,26 @@ module Thespian
       it "that is initialized" do
         actor.should be_initialized
       end
+
+      it "using the Thread strategy" do
+        actor.strategy.should be_a(Strategy::Thread)
+      end
+
+      if supports_fibers?
+
+        it "using the Fiber strategy" do
+          actor = Actor.new(:mode => :fiber).extend(ActorHelper)
+          actor.strategy.should be_a(Strategy::Fiber)
+        end
+
+      else
+
+        it "raises an exception if trying to run in fibered mode" do
+          expect{ Actor.new(:mode => :fiber) }.to raise_error(RuntimeError)
+        end
+
+      end
+
     end
 
     context "#link" do
@@ -36,9 +57,9 @@ module Thespian
     end
 
     context "#start" do
-      let(:actor){ Actor.new.extend(ActorHelper) }
 
-      before(:all) do
+      before(:each) do
+        stub(actor.strategy).start
         actor.start
       end
 
@@ -46,43 +67,41 @@ module Thespian
         actor.should be_running
       end
 
-      it "starts a thread" do
-        actor.thread.should be_alive
+      it "calls Strategy#start" do
+        actor.strategy.should have_received.start
       end
     end
 
     context "#receive" do
-      let(:actor){ Actor.new.extend(ActorHelper) }
 
       it "returns the next message from the actor's mailbox" do
-        actor.mailbox << "hello"
+        mock(actor.strategy).receive{ "hello" }
         actor.receive.should == "hello"
       end
 
       it "raises a DeadActorError if that's what's in the mailbox" do
-        actor.mailbox << DeadActorError.new(actor, "blah")
+        mock(actor.strategy).receive{ DeadActorError.new(actor, "blah") }
         expect{ actor.receive }.to raise_error(DeadActorError)
       end
 
       it "raises a Stop exception if that's what's in the mailbox" do
-        actor.mailbox << Stop.new
+        mock(actor.strategy).receive{ Stop.new }
         expect{ actor.receive }.to raise_error(Stop)
       end
 
       it "returns DeadActorError if trap_exit is true and that's what's in the mailbox" do
-        actor.mailbox << DeadActorError.new(actor, "blah")
+        mock(actor.strategy).receive{ DeadActorError.new(actor, "blah") }
         actor.options(:trap_exit => true)
         actor.receive.should be_a(DeadActorError)
       end
     end
 
     context "#<<" do
-      let(:actor){ Actor.new.extend(ActorHelper) }
 
       it "puts an item into the mailbox" do
         stub(actor).running?{ true }
+        mock(actor.strategy).<<("hello")
         actor << "hello"
-        actor.mailbox.should include("hello")
       end
 
       it "raises a RuntimeError if the actor isn't alive" do
@@ -93,23 +112,22 @@ module Thespian
       it "works on a dead actor if strict is false" do
         actor.should_not be_running
         actor.options :strict => false
+        mock(actor.strategy).<<("blah")
         actor << "blah"
-        actor.mailbox.should include("blah")
       end
     end
 
     context "#stop" do
-      let(:actor){ Actor.new.extend(ActorHelper) }
 
       it "raises an exception if the actor isn't alive" do
         expect{ actor.stop }.to raise_error(RuntimeError, /not running/i)
       end
 
       it "puts a Stop message in the actor's mailbox" do
-        mock(actor).running?{ true }.times(2)
-        mock(actor.thread).join
+        stub(actor).check_alive!{ true }
+        mock(actor.strategy).<<(is_a(Stop))
+        mock(actor.strategy).stop
         actor.stop
-        actor.mailbox[0].should be_a(Stop)
       end
     end
 
@@ -121,21 +139,25 @@ module Thespian
       end
 
       it "doesn't include the last message if the actor stopped properly" do
-        actor = Actor.new.extend(ActorHelper)
-        actor.mailbox.replace([1, 2, 3, Stop.new, 4, 5])
-        actor.start
-        Thread.pass while actor.running?
-        actor.salvage_mailbox.should == [4, 5]
+        mock(actor.strategy).messages{ [2, 3] }
+        mock(actor).finished?{ true }
+        actor.salvage_mailbox.should == [2, 3]
       end
 
       it "includes the last message if the actor error'ed" do
-        actor = Actor.new do |message|
-          raise "oops" if message == 3
-        end.extend(ActorHelper)
-        actor.mailbox.replace([1, 2, 3, 4, 5])
-        actor.start
-        Thread.pass while actor.running?
-        actor.salvage_mailbox.should == [3, 4, 5]
+        actor.instance_eval{ @last_message = 1 }
+        mock(actor.strategy).messages{ [2, 3] }
+        mock(actor).finished?{ true }
+        actor.salvage_mailbox.should == [1, 2, 3]
+      end
+
+    end
+
+    context "#mailbox_size" do
+
+      it "returns how many messages are in the mailbox" do
+        mock(actor.strategy).mailbox_size{ 3 }
+        actor.mailbox_size.should == 3
       end
 
     end

data/spec/classes_spec.rb

@@ -0,0 +1,22 @@
+module Thespian
+  describe "Thespian when used with classes" do
+
+    it "processes messages with the block defined by the actor method in the class" do
+      klass = Class.new do
+        attr_reader :messages
+        include Thespian
+        actor do |message|
+          @messages ||= []
+          @messages << message
+        end
+      end
+
+      object = klass.new
+      object.actor.start
+      object.actor << 1 << 2 << 3
+      object.actor.stop
+      object.messages.should == [1, 2, 3]
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -1,32 +1,25 @@
 require "thespian"
+require "rr"
+require "pry"
 
-module ActorHelper
-
-  def linked_actors
-    @linked_actors
-  end
-
-  def thread
-    @thread
-  end
+# Shared examples
+require "strategies/interface"
 
-  def mailbox
-    @mailbox
-  end
+module ActorHelper
 
-  def mailbox_cond
-    @mailbox_cond
+  def self.extended(object)
+    class << object
+      public :strategy
+      public :receive
+    end
   end
 
-  # To get around receive being private
-  def receive
-    super
+  def linked_actors
+    @linked_actors
   end
 
 end
 
-require 'rr'
-
 module RR
   module Adapters
     module RSpec2
@@ -64,3 +57,12 @@ RSpec.configure do |config|
   config.mock_with :rr
 end
 
+def supports_fibers?
+  begin
+    require "fiber"
+  rescue LoadError
+    false
+  else
+    true
+  end
+end