celluloid 0.14.1 → 0.15.0.pre

data/lib/celluloid/tasks.rb

@@ -1,13 +1,18 @@
 module Celluloid
   # Asked to do task-related things outside a task
-  class NotTaskError < StandardError; end
+  class NotTaskError < Celluloid::Error; end
 
   # Trying to resume a dead task
-  class DeadTaskError < StandardError; end
+  class DeadTaskError < Celluloid::Error; end
+
+  # Errors which should be resumed automatically
+  class ResumableError < Celluloid::Error; end
 
   # Tasks are interruptable/resumable execution contexts used to run methods
   class Task
-    class TerminatedError < StandardError; end # kill a running task
+    class TerminatedError < ResumableError; end # kill a running task after terminate
+
+    class TimeoutError < ResumableError; end # kill a running task after timeout
 
     # Obtain the current task
     def self.current
@@ -19,15 +24,20 @@ module Celluloid
       Task.current.suspend(status)
     end
 
-    attr_reader :type, :status
+    attr_reader :type, :meta, :status
+    attr_accessor :chain_id
 
     # Create a new task
-    def initialize(type)
-      @type   = type
-      @status = :new
+    def initialize(type, meta)
+      @type     = type
+      @meta     = meta
+      @status   = :new
 
-      actor    = Thread.current[:celluloid_actor]
-      chain_id = Thread.current[:celluloid_chain_id]
+      @exclusive         = false
+      @dangerous_suspend = @meta ? @meta.delete(:dangerous_suspend) : false
+
+      actor     = Thread.current[:celluloid_actor]
+      @chain_id = CallChain.current_id
 
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
@@ -35,8 +45,9 @@ module Celluloid
         begin
           @status = :running
           actor.setup_thread
-          Thread.current[:celluloid_task]     = self
-          Thread.current[:celluloid_chain_id] = chain_id
+
+          Thread.current[:celluloid_task] = self
+          CallChain.current_id = @chain_id
 
           actor.tasks << self
           yield
@@ -55,11 +66,25 @@ module Celluloid
 
     # Suspend the current task, changing the status to the given argument
     def suspend(status)
+      raise "Cannot suspend while in exclusive mode" if exclusive?
+
       @status = status
+
+      if $CELLULOID_DEBUG && @dangerous_suspend
+        warning = "Dangerously suspending task: "
+        warning << [
+          "type=#{@type.inspect}",
+          "meta=#{@meta.inspect}",
+          "status=#{@status.inspect}"
+        ].join(", ")
+
+        Logger.warn [warning, *caller[2..8]].join("\n\t")
+      end
+
       value = signal
 
-      raise value if value.is_a?(Task::TerminatedError)
       @status = :running
+      raise value if value.is_a?(Celluloid::ResumableError)
 
       value
     end
@@ -70,9 +95,37 @@ module Celluloid
       nil
     end
 
+    # Execute a code block in exclusive mode.
+    def exclusive
+      if @exclusive
+        yield
+      else
+        begin
+          @exclusive = true
+          yield
+        ensure
+          @exclusive = false
+        end
+      end
+    end
+
     # Terminate this task
     def terminate
-      resume Task::TerminatedError.new("task was terminated") if running?
+      raise "Cannot terminate an exclusive task" if exclusive?
+
+      if running?
+        Celluloid.logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        exception = Task::TerminatedError.new("task was terminated")
+        exception.set_backtrace(caller)
+        resume exception
+      else
+        raise DeadTaskError, "task is already dead"
+      end
+    end
+
+    # Is this task running in exclusive mode?
+    def exclusive?
+      @exclusive
     end
 
     def backtrace
@@ -83,35 +136,7 @@ module Celluloid
 
     # Nicer string inspect for tasks
     def inspect
-      "#<#{self.class}:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
-    end
-  end
-  
-  class TaskSet
-    include Enumerable
-  
-    def initialize
-      @tasks = Set.new
-    end
-  
-    def <<(task)
-      @tasks += [task]
-    end
-  
-    def delete(task)
-      @tasks -= [task]
-    end
-  
-    def each(&blk)
-      @tasks.each(&blk)
-    end
-  
-    def first
-      @tasks.first
-    end
-    
-    def empty?
-      @tasks.empty?
+      "#<#{self.class}:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @meta=#{@meta.inspect}, @status=#{@status.inspect}>"
     end
   end
 end

data/lib/celluloid/tasks/task_fiber.rb

@@ -1,13 +1,15 @@
 module Celluloid
-  class FiberStackError < StandardError; end
+  class FiberStackError < Celluloid::Error; end
 
   # Tasks with a Fiber backend
   class TaskFiber < Task
 
     def create
+      queue = Thread.current[:celluloid_queue]
       @fiber = Fiber.new do
         # FIXME: cannot use the writer as specs run inside normal Threads
         Thread.current[:celluloid_role] = :actor
+        Thread.current[:celluloid_queue] = queue
         yield
       end
     end

data/lib/celluloid/tasks/task_thread.rb

@@ -2,7 +2,7 @@ module Celluloid
   # Tasks with a Thread backend
   class TaskThread < Task
     # Run the given block within a task
-    def initialize(type)
+    def initialize(type, meta)
       @resume_queue = Queue.new
       @exception_queue = Queue.new
       @yield_mutex  = Mutex.new
@@ -12,8 +12,7 @@ module Celluloid
     end
 
     def create
-      @thread = Celluloid.internal_pool.get do
-        Thread.current.role = :task
+      @thread = Celluloid::ThreadHandle.new(:task) do
         begin
           ex = @resume_queue.pop
           raise ex if ex.is_a?(Task::TerminatedError)

data/lib/celluloid/thread.rb

@@ -6,6 +6,8 @@ module Celluloid
       true
     end
 
+    attr_accessor :busy
+
     # Obtain the role of this thread
     def role
       self[:celluloid_role]

data/spec/celluloid/actor_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Celluloid do
+  it_behaves_like "a Celluloid Actor", Celluloid
+end

data/spec/celluloid/block_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe "Blocks" do
+  class MyBlockActor
+    include Celluloid
+
+    def initialize(name)
+      @name = name
+    end
+    attr_reader :name
+
+    def ask_for_something(other)
+      sender_actor = current_actor
+      $data << [:outside, @name, current_actor.name]
+      other.do_something_and_callback do |value|
+        $data << [:yielded, @name, current_actor.name]
+        $data << self.receive_result(:self)
+        $data << current_actor.receive_result(:current_actor)
+        $data << sender_actor.receive_result(:sender)
+        "somevalue"
+      end
+    end
+
+    def do_something_and_callback
+      $data << [:something, @name, current_actor.name]
+      $data << yield(:foo)
+    end
+
+    def receive_result(result)
+      [result, @name, current_actor.name]
+    end
+  end
+
+  it "works" do
+    $data = []
+
+    a1 = MyBlockActor.new("one")
+    a2 = MyBlockActor.new("two")
+
+    a1.ask_for_something a2
+
+    expected = [
+      [:outside, "one", "one"],
+      [:something, "two", "two"],
+      [:yielded, "one", "one"],
+      [:self, "one", "one"],
+      [:current_actor, "one", "one"],
+      [:sender, "one", "one"],
+      "somevalue",
+    ]
+
+    $data.should eq(expected)
+  end
+end

data/spec/celluloid/calls_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Celluloid::SyncCall do
+  class CallExampleActor
+    include Celluloid
+
+    def initialize(next_actor = nil)
+      @next = next_actor
+    end
+
+    def actual_method; end
+
+    def chained_call_ids
+      [call_chain_id, @next.call_chain_id]
+    end
+  end
+
+  let(:actor) { CallExampleActor.new }
+
+  it "aborts with NoMethodError when a nonexistent method is called" do
+    expect do
+      actor.the_method_that_wasnt_there
+    end.to raise_exception(NoMethodError)
+
+    actor.should be_alive
+  end
+
+  it "aborts with ArgumentError when a method is called with too many arguments" do
+    expect do
+      actor.actual_method("with too many arguments")
+    end.to raise_exception(ArgumentError)
+
+    actor.should be_alive
+  end
+
+  it "preserves call chains across synchronous calls" do
+    actor2 = CallExampleActor.new(actor)
+
+    uuid, next_actor_uuid = actor2.chained_call_ids
+    uuid.should eq next_actor_uuid
+  end
+end

data/spec/celluloid/condition_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Celluloid::Condition do
+  class ConditionExample
+    include Celluloid
+
+    attr_reader :condition, :signaled_times
+
+    def initialize
+      @condition = Condition.new
+
+      @waiting  = false
+      @signaled_times = 0
+    end
+
+    def signal_condition(condition, value)
+      condition.signal value
+    end
+
+    def wait_for_condition
+      @waiting = true
+      begin
+        value = @condition.wait
+        @signaled_times += 1
+      ensure
+        @waiting = false
+      end
+
+      value
+    end
+
+    def waiting?; @waiting end
+  end
+
+  let(:actor) { ConditionExample.new }
+  after { actor.terminate rescue nil }
+
+  it "sends signals" do
+    3.times { actor.async.wait_for_condition }
+    actor.signaled_times.should be_zero
+
+    actor.condition.signal
+    actor.signaled_times.should be(1)
+  end
+
+  it "broadcasts signals" do
+    3.times { actor.async.wait_for_condition }
+    actor.signaled_times.should be_zero
+
+    actor.condition.broadcast
+    actor.signaled_times.should be(3)
+  end
+
+  it "sends values along with signals" do
+    future = actor.future(:wait_for_condition)
+    actor.condition.signal(:example_value)
+    future.value.should be(:example_value)
+  end
+
+  it "supports waiting outside actors" do
+    condition = Celluloid::Condition.new
+    actor.async.signal_condition condition, :value
+    condition.wait.should eq(:value)
+  end
+end

data/spec/celluloid/evented_mailbox_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class TestEventedMailbox < Celluloid::EventedMailbox
+  class Reactor
+    def initialize
+      @condition = ConditionVariable.new
+      @mutex = Mutex.new
+    end
+
+    def wakeup
+      @mutex.synchronize do
+        @condition.signal
+      end
+    end
+
+    def run_once(timeout)
+      @mutex.synchronize do
+        @condition.wait(@mutex, timeout)
+      end
+    end
+
+    def shutdown
+    end
+  end
+
+  def initialize
+    super(Reactor)
+  end
+end
+
+describe Celluloid::EventedMailbox do
+  subject { TestEventedMailbox.new }
+  it_behaves_like "a Celluloid Mailbox"
+end

data/spec/celluloid/fsm_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Celluloid::FSM do
+  before :all do
+    class TestMachine
+      include Celluloid::FSM
+
+      def initialize
+        super
+        @fired = false
+      end
+
+      state :callbacked do
+        @fired = true
+      end
+
+      state :pre_done, :to => :done
+      state :another, :done
+
+      def fired?; @fired end
+    end
+
+    class DummyActor
+      include Celluloid
+    end
+
+    class CustomDefaultMachine
+      include Celluloid::FSM
+
+      default_state :foobar
+    end
+  end
+
+  subject { TestMachine.new }
+
+  it "starts in the default state" do
+    subject.state.should eq(TestMachine.default_state)
+  end
+
+  it "transitions between states" do
+    subject.state.should_not be :done
+    subject.transition :done
+    subject.state.should be :done
+  end
+
+  it "fires callbacks for states" do
+    subject.should_not be_fired
+    subject.transition :callbacked
+    subject.should be_fired
+  end
+
+  it "allows custom default states" do
+    CustomDefaultMachine.new.state.should be :foobar
+  end
+
+  it "supports constraints on valid state transitions" do
+    subject.transition :pre_done
+    expect { subject.transition :another }.to raise_exception ArgumentError
+  end
+
+  it "transitions to states after a specified delay" do
+    interval = Celluloid::TIMER_QUANTUM * 10
+
+    subject.attach DummyActor.new
+    subject.transition :another
+    subject.transition :done, :delay => interval
+
+    subject.state.should be :another
+    sleep interval + Celluloid::TIMER_QUANTUM
+
+    subject.state.should be :done
+  end
+
+  it "cancels delayed state transitions if another transition is made" do
+    interval = Celluloid::TIMER_QUANTUM * 10
+
+    subject.attach DummyActor.new
+    subject.transition :another
+    subject.transition :done, :delay => interval
+
+    subject.state.should be :another
+    subject.transition :pre_done
+    sleep interval + Celluloid::TIMER_QUANTUM
+
+    subject.state.should be :pre_done
+  end
+
+  context "actor is not set" do
+    context "transition is delayed" do
+      it "raises an unattached error" do
+        expect { subject.transition :another, :delay => 100 } \
+          .to raise_error(Celluloid::FSM::UnattachedError)
+      end
+    end
+  end
+
+  context "transitioning to an invalid state" do
+    it "raises an argument error" do
+      expect { subject.transition :invalid_state }.to raise_error(ArgumentError)
+    end
+
+    it "should not call transition! if the state is :default" do
+      subject.should_not_receive :transition!
+      subject.transition :default
+    end
+  end
+end