celluloid 0.13.0 → 0.14.0.pre

data/lib/celluloid/thread.rb

@@ -0,0 +1,82 @@
+require 'celluloid/fiber'
+
+module Celluloid
+  class Thread < ::Thread
+    # FIXME: these should be replaced using APIs on Celluloid::Thread itself
+    # e.g. Thread.current[:celluloid_actor] => Thread.current.actor
+    CELLULOID_LOCALS = [
+      :celluloid_actor,
+      :celluloid_mailbox,
+      :celluloid_queue,
+      :celluloid_task,
+      :celluloid_chain_id
+    ]
+
+    # A roundabout way to avoid purging :celluloid_queue
+    EPHEMERAL_CELLULOID_LOCALS = CELLULOID_LOCALS - [:celluloid_queue]
+
+    def celluloid?
+      true
+    end
+
+    # Obtain the Celluloid::Actor object for this thread
+    def actor
+      self[:celluloid_actor]
+    end
+
+    # Obtain the Celluloid task object for this thread
+    def task
+      self[:celluloid_task]
+    end
+
+    # Obtain the Celluloid mailbox for this thread
+    def mailbox
+      self[:celluloid_mailbox]
+    end
+
+    # Obtain the call chain ID for this thread
+    def call_chain_id
+      self[:celluloid_chain_id]
+    end
+
+    #
+    # Override default thread local behavior, making thread locals actor-local
+    #
+
+    # Obtain an actor-local value
+    def [](key)
+      if CELLULOID_LOCALS.include?(key)
+        super(key)
+      else
+        actor = super(:celluloid_actor)
+        actor.locals[key] if actor
+      end
+    end
+
+    # Set an actor-local value
+    def []=(key, value)
+      if CELLULOID_LOCALS.include?(key)
+        super(key, value)
+      else
+        self[:celluloid_actor].locals[key] = value
+      end
+    end
+
+    # Obtain the keys to all actor-locals
+    def keys
+      actor = self[:celluloid_actor]
+      actor.locals.keys if actor
+    end
+
+    # Is the given actor local set?
+    def key?(key)
+      actor = self[:celluloid_actor]
+      actor.locals.has_key?(key) if actor
+    end
+
+    # Clear thread state so it can be reused via thread pools
+    def recycle
+      EPHEMERAL_CELLULOID_LOCALS.each { |local| self[local] = nil }
+    end
+  end
+end

data/lib/celluloid/thread_handle.rb

@@ -31,8 +31,9 @@ module Celluloid
     end
 
     # Join to a running thread, blocking until it terminates
-    def join
-      @mutex.synchronize { @join.wait(@mutex) if @thread }
+    def join(limit = nil)
+      raise ThreadError, "Target thread must not be current thread" if @thread == Thread.current
+      @mutex.synchronize { @join.wait(@mutex, limit) if @thread }
       self
     end
 

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.13.0'
+  VERSION = '0.14.0.pre'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -1,13 +1,22 @@
-shared_context "a Celluloid Actor" do |included_module|
+shared_examples "a Celluloid Actor" do |included_module|
+  describe "using Fibers" do
+    include_examples "Celluloid::Actor examples", included_module, Celluloid::TaskFiber
+  end
+  describe "using Threads" do
+    include_examples "Celluloid::Actor examples", included_module, Celluloid::TaskThread
+  end
+end
+
+shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
   class ExampleCrash < StandardError
     attr_accessor :foo
   end
 
-  let(:actor_class) { ExampleActorClass.create(included_module) }
+  let(:actor_class) { ExampleActorClass.create(included_module, task_klass) }
 
   it "returns the actor's class, not the proxy's" do
     actor = actor_class.new "Troy McClure"
-    actor.class.should == actor_class
+    actor.class.should eq(actor_class)
   end
 
   it "compares with the actor's class in a case statement" do
@@ -21,13 +30,13 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "can be stored in hashes" do
     actor = actor_class.new "Troy McClure"
-    actor.hash.should_not == Kernel.hash
-    actor.object_id.should_not == Kernel.object_id
+    actor.hash.should_not eq(Kernel.hash)
+    actor.object_id.should_not eq(Kernel.object_id)
   end
 
   it "supports synchronous calls" do
     actor = actor_class.new "Troy McClure"
-    actor.greet.should == "Hi, I'm Troy McClure"
+    actor.greet.should eq("Hi, I'm Troy McClure")
   end
 
   it "supports synchronous calls with blocks" do
@@ -40,32 +49,33 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "supports synchronous calls via #method" do
     method = actor_class.new("Troy McClure").method(:greet)
-    method.call.should == "Hi, I'm Troy McClure"
+    method.call.should eq("Hi, I'm Troy McClure")
   end
 
   it "supports #arity calls via #method" do
     method = actor_class.new("Troy McClure").method(:greet)
-    method.arity.should == 0
+    method.arity.should be(0)
 
     method = actor_class.new("Troy McClure").method(:change_name)
-    method.arity.should == 1
+    method.arity.should be(1)
   end
 
   it "supports future(:method) syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
-    future.value.should == "Hi, I'm Troy McClure"
+    future.value.should eq("Hi, I'm Troy McClure")
   end
 
   it "supports future.method syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future.greet
-    future.value.should == "Hi, I'm Troy McClure"
+    future.value.should eq("Hi, I'm Troy McClure")
   end
 
   it "handles circular synchronous calls" do
     klass = Class.new do
       include included_module
+      task_class task_klass
 
       def greet_by_proxy(actor)
         actor.greet
@@ -78,13 +88,13 @@ shared_context "a Celluloid Actor" do |included_module|
 
     ponycopter = klass.new
     actor = actor_class.new ponycopter
-    ponycopter.greet_by_proxy(actor).should == "Hi, I'm a ponycopter!"
+    ponycopter.greet_by_proxy(actor).should eq("Hi, I'm a ponycopter!")
   end
 
   it "properly handles method_missing" do
     actor = actor_class.new "Method Missing"
     actor.should respond_to(:first)
-    actor.first.should be == :bar
+    actor.first.should be :bar
   end
 
   it "properly handles respond_to with include_private" do
@@ -103,19 +113,19 @@ shared_context "a Celluloid Actor" do |included_module|
   it "supports async(:method) syntax for asynchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.async :change_name, "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+    actor.greet.should eq("Hi, I'm Charlie Sheen")
   end
 
   it "supports async.method syntax for asynchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.async.change_name "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+    actor.greet.should eq("Hi, I'm Charlie Sheen")
   end
 
   it "supports async.method syntax for asynchronous calls to itself" do
     actor = actor_class.new "Troy McClure"
     actor.change_name_async "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+    actor.greet.should eq("Hi, I'm Charlie Sheen")
   end
 
   it "allows an actor to call private methods asynchronously" do
@@ -129,6 +139,9 @@ shared_context "a Celluloid Actor" do |included_module|
     actor = actor_class.new "Troy McClure"
     actor.run do
       Celluloid.actor?
+    end.should be_false
+    actor.run_on_receiver do
+      Celluloid.actor?
     end.should be_true
     actor.should be_actor
   end
@@ -144,7 +157,7 @@ shared_context "a Celluloid Actor" do |included_module|
   it "inspects properly when dead" do
     actor = actor_class.new "Troy McClure"
     actor.terminate
-    actor.inspect.should match(/Celluloid::Actor\(/)
+    actor.inspect.should match(/Celluloid::ActorProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('dead')
   end
@@ -164,7 +177,7 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "can override #send" do
     actor = actor_class.new "Troy McClure"
-    actor.send('foo').should == 'oof'
+    actor.send('foo').should eq('oof')
   end
 
   context "mocking methods" do
@@ -175,16 +188,16 @@ shared_context "a Celluloid Actor" do |included_module|
     end
 
     it "works externally via the proxy" do
-      actor.external_hello.should == "World"
+      actor.external_hello.should eq("World")
     end
 
     it "works internally when called on self" do
-      actor.internal_hello.should == "World"
+      actor.internal_hello.should eq("World")
     end
   end
 
   context :exceptions do
-    it "reraises exceptions which occur during synchronous calls in the caller" do
+    it "reraises exceptions which occur during synchronous calls in the sender" do
       actor = actor_class.new "James Dean" # is this in bad taste?
 
       expect do
@@ -192,9 +205,10 @@ shared_context "a Celluloid Actor" do |included_module|
       end.to raise_exception(ExampleCrash)
     end
 
-    it "includes both caller and receiver in exception traces" do
+    it "includes both sender and receiver in exception traces" do
       ExampleReceiver = Class.new do
         include included_module
+        task_class task_klass
 
         def receiver_method
           raise ExampleCrash, "the spec purposely crashed me :("
@@ -203,20 +217,21 @@ shared_context "a Celluloid Actor" do |included_module|
 
       ExampleCaller = Class.new do
         include included_module
+        task_class task_klass
 
-        def caller_method
+        def sender_method
           ExampleReceiver.new.receiver_method
         end
       end
 
       ex = nil
       begin
-        ExampleCaller.new.caller_method
+        ExampleCaller.new.sender_method
       rescue => ex
       end
 
       ex.should be_a ExampleCrash
-      ex.backtrace.grep(/`caller_method'/).should be_true
+      ex.backtrace.grep(/`sender_method'/).should be_true
       ex.backtrace.grep(/`receiver_method'/).should be_true
     end
 
@@ -231,7 +246,7 @@ shared_context "a Celluloid Actor" do |included_module|
   end
 
   context :abort do
-    it "raises exceptions in the caller but keeps running" do
+    it "raises exceptions in the sender but keeps running" do
       actor = actor_class.new "Al Pacino"
 
       expect do
@@ -248,7 +263,7 @@ shared_context "a Celluloid Actor" do |included_module|
       end.to raise_exception(RuntimeError, "foo")
     end
 
-    it "crashes the caller if we pass neither String nor Exception" do
+    it "crashes the sender if we pass neither String nor Exception" do
       actor = actor_class.new "Al Pacino"
       expect do
         actor.crash_with_abort_raw 10
@@ -308,6 +323,30 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context "thread locals" do
+    let(:example_class) do
+      Class.new do
+        include included_module
+        task_class task_klass
+
+        def initialize(value)
+          Thread.current[:example_thread_local] = value
+        end
+
+        def value
+          Thread.current[:example_thread_local]
+        end
+      end
+    end
+
+    let(:example_value) { "foobar" }
+
+    it "preserves thread locals between tasks" do
+      actor = example_class.new(example_value)
+      actor.value.should eq example_value
+    end
+  end
+
   context :linking do
     before :each do
       @kevin   = actor_class.new "Kevin Bacon" # Some six degrees action here
@@ -317,6 +356,7 @@ shared_context "a Celluloid Actor" do |included_module|
     let(:supervisor_class) do
       Class.new do # like a boss
         include included_module
+        task_class task_klass
         trap_exit :lambaste_subordinate
 
         def initialize(name)
@@ -403,7 +443,7 @@ shared_context "a Celluloid Actor" do |included_module|
       end.to raise_exception(ExampleCrash)
 
       sleep 0.1 # hax to prevent a race between exit handling and the next call
-      chuck.links.count.should == 0
+      chuck.links.count.should be(0)
     end
   end
 
@@ -411,6 +451,7 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @signaler = Class.new do
         include included_module
+        task_class task_klass
 
         def initialize
           @waiting  = false
@@ -466,7 +507,7 @@ shared_context "a Celluloid Actor" do |included_module|
       obj.should_not be_signaled
 
       obj.send_signal(:foobar).should be_true
-      future.value.should == :foobar
+      future.value.should be(:foobar)
     end
   end
 
@@ -474,6 +515,7 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
+        task_class task_klass
 
         attr_reader :tasks
 
@@ -516,14 +558,14 @@ shared_context "a Celluloid Actor" do |included_module|
       subject.async.exclusive_with_block_log_task(:one)
       subject.async.log_task(:two)
       sleep Celluloid::TIMER_QUANTUM * 2
-      subject.tasks.should == [:one, :two]
+      subject.tasks.should eq([:one, :two])
     end
 
     it "executes methods in the proper order with a class-level annotation" do
       subject.async.exclusive_log_task :one
       subject.async.log_task :two
       sleep Celluloid::TIMER_QUANTUM * 2
-      subject.tasks.should == [:one, :two]
+      subject.tasks.should eq([:one, :two])
     end
 
     it "knows when it's in exclusive mode" do
@@ -540,6 +582,7 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
+        task_class task_klass
         exclusive
 
         attr_reader :tasks
@@ -564,7 +607,7 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.async.eat_donuts
       actor.async.drink_coffee
       sleep Celluloid::TIMER_QUANTUM * 2
-      actor.tasks.should == ['donuts', 'coffee']
+      actor.tasks.should eq(['donuts', 'coffee'])
     end
   end
 
@@ -572,6 +615,8 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @receiver = Class.new do
         include included_module
+        task_class task_klass
+        execute_block_on_receiver :signal_myself
 
         def signal_myself(obj, &block)
           current_actor.mailbox << obj
@@ -584,12 +629,12 @@ shared_context "a Celluloid Actor" do |included_module|
     let(:message) { Object.new }
 
     it "allows unconditional receive" do
-      receiver.signal_myself(message).should == message
+      receiver.signal_myself(message).should eq(message)
     end
 
     it "allows arbitrary selective receive" do
       received_obj = receiver.signal_myself(message) { |o| o == message }
-      received_obj.should == message
+      received_obj.should eq(message)
     end
 
     it "times out after the given interval", :pending => ENV['CI'] do
@@ -605,6 +650,7 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @klass = Class.new do
         include included_module
+        task_class task_klass
 
         def initialize
           @sleeping = false
@@ -653,9 +699,8 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
 
-      timer = actor.fire_after(interval)
+      actor.fire_after(interval)
       actor.should_not be_fired
 
       sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
@@ -666,23 +711,21 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
 
-      timer = actor.fire_every(interval)
-      actor.fired.should be == 0
+      actor.fire_every(interval)
+      actor.fired.should be_zero
 
       sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
-      actor.fired.should be == 1
+      actor.fired.should be 1
 
       2.times { sleep(interval + Celluloid::TIMER_QUANTUM) } # wonky! #/
-      actor.fired.should be == 3
+      actor.fired.should be 3
     end
 
     it "cancels timers before they fire" do
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
 
       timer = actor.fire_after(interval)
       actor.should_not be_fired
@@ -696,10 +739,9 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
       fired = false
 
-      timer = actor.after(interval) do
+      actor.after(interval) do
         fired = true
       end
       fired.should be_false
@@ -713,6 +755,7 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @klass = Class.new do
         include included_module
+        task_class task_klass
         attr_reader :blocker
 
         def initialize
@@ -741,21 +784,21 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       tasks = actor.tasks
-      tasks.size.should == 1
+      tasks.size.should be 1
 
-      future = actor.future(:blocking_call)
+      actor.future(:blocking_call)
       sleep 0.1 # hax! waiting for ^^^ call to actually start
 
       tasks = actor.tasks
-      tasks.size.should == 2
+      tasks.size.should be 2
 
       blocking_task = tasks.find { |t| t.status != :running }
-      blocking_task.should be_a Celluloid.task_class
-      blocking_task.status.should == :callwait
+      blocking_task.should be_a task_klass
+      blocking_task.status.should be :callwait
 
       actor.blocker.unblock
       sleep 0.1 # hax again :(
-      actor.tasks.size.should == 1
+      actor.tasks.size.should be 1
     end
   end
 
@@ -765,6 +808,7 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
+        task_class task_klass
         mailbox_class ExampleMailbox
       end
     end
@@ -779,23 +823,42 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context :mailbox_limit do
+    subject do
+      Class.new do
+        include included_module
+        task_class task_klass
+        mailbox.max_size = 100
+      end
+    end
+
+    it "configures the mailbox limit" do
+      subject.new.mailbox.max_size.should == 100
+    end
+  end
+
   context :proxy_class do
-    class ExampleProxy < Celluloid::ActorProxy; end
+    class ExampleProxy < Celluloid::ActorProxy
+      def subclass_proxy?
+        true
+      end
+    end
 
     subject do
       Class.new do
         include included_module
+        task_class task_klass
         proxy_class ExampleProxy
       end
     end
 
     it "uses user-specified proxy" do
-      subject.new.__class__.should == ExampleProxy
+      subject.new.should be_subclass_proxy
     end
 
     it "retains custom proxy when subclassed" do
       subclass = Class.new(subject)
-      subclass.new.__class__.should == ExampleProxy
+      subclass.new.should be_subclass_proxy
     end
   end